Déployer un honeypot avec Cowrie

Introduction

Dans ce laboratoire (lab), vous apprendrez à déployer Cowrie, un honeypot SSH à interaction moyenne qui capture et analyse le comportement des attaquants. Vous allez configurer Cowrie dans un environnement virtuel Python et le configurer pour imiter un service SSH réel tout en activant une journalisation complète.

Grâce à cette expérience pratique, vous allez tester le honeypot en simulant des attaques et en analysant les journaux générés. Cette expérience pratique vous aidera à comprendre comment les honeypots fonctionnent comme outils de cybersécurité pour la détection et l'analyse des menaces.

Installer Cowrie

Dans cette étape, vous allez installer Cowrie, un honeypot SSH à interaction moyenne conçu pour enregistrer les attaques de force brute et les interactions shell effectuées par les attaquants. Cowrie est implémenté en Python et peut être facilement installé à l'aide de pip. Un honeypot est un mécanisme de sécurité qui imite des systèmes réels pour attirer et étudier les activités malveillantes, aidant les professionnels de la sécurité à comprendre les modèles d'attaque.

Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut. C'est là que nous allons organiser tous les fichiers du projet :
```
cd ~/project
```
Installez les dépendances système requises pour Cowrie. Ces paquets fournissent les composants essentiels nécessaires au bon fonctionnement de Cowrie, notamment les outils de développement Python et les bibliothèques cryptographiques :
```
sudo apt-get update && sudo apt-get install -y python3-venv python3-dev libssl-dev libffi-dev build-essential
```
Créez un environnement virtuel Python pour Cowrie. Les environnements virtuels isolent les dépendances du projet de votre installation Python système, évitant ainsi les conflits potentiels :
```
python3 -m venv cowrie-env
```
Activez l'environnement virtuel. Une fois activé, tous les paquets Python que vous installerez iront dans cet environnement isolé plutôt que dans votre Python système :
```
source cowrie-env/bin/activate
```
Installez Cowrie à l'aide de pip. Pip est le gestionnaire de paquets Python qui téléchargera et installera Cowrie ainsi que ses dépendances :
```
pip install cowrie
```
Vérifiez l'installation en vérifiant la version de Cowrie. Cela confirme que le paquet a été installé correctement et indique la version que vous utilisez :
```
cowrie --version
```
Vous devriez voir une sortie similaire à :
```
cowrie 2.1.0
```
Désactivez l'environnement virtuel une fois terminé. Cela vous ramène à l'environnement Python par défaut de votre système :
```
deactivate
```

Configurer les paramètres du honeypot

Dans cette étape, vous allez configurer les paramètres du honeypot Cowrie pour personnaliser son comportement et ses capacités de journalisation. Les fichiers de configuration agissent comme le cerveau de votre honeypot, déterminant comment il interagit avec les attaquants potentiels et quelles données sont enregistrées pour l'analyse.

Tout d'abord, activez l'environnement virtuel Python créé à l'étape précédente. Cela isole les dépendances de Cowrie de votre Python système :
```
cd ~/project
source cowrie-env/bin/activate
```
Générez les fichiers de configuration par défaut. Ces modèles contiennent tous les paramètres disponibles avec leurs valeurs par défaut :
```
cowrie-gen-config
```
Cela créera des fichiers de configuration dans ~/project/cowrie-env/etc/cowrie/
Modifiez le fichier de configuration principal à l'aide de nano, un éditeur de texte convivial pour les débutants :
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Modifiez les paramètres clés suivants (utilisez les touches fléchées pour naviguer, Ctrl+O pour enregistrer, Ctrl+X pour quitter) :
- Changez listen_port = 2222 en listen_port = 22 - cela fait apparaître le honeypot comme un serveur SSH standard
- Réglez enabled = true dans la section [output_json] - active la journalisation structurée pour une analyse plus facile
- Réglez enabled = true dans la section [output_textlog] - fournit des journaux lisibles par l'homme
Créez un répertoire dédié aux fichiers de journalisation. Conserver les journaux séparés facilite l'organisation et l'analyse :
```
mkdir -p ~/project/cowrie-logs
```
Mettez à jour le chemin de journalisation dans la configuration pour pointer vers votre nouveau répertoire :
```
nano cowrie-env/etc/cowrie/cowrie.cfg
```
Trouvez le paramètre log_path et changez-le en :
```
log_path = /home/labex/project/cowrie-logs
```
Vérifiez vos modifications de configuration en vérifiant les paramètres modifiés :
```
grep -E 'listen_port|enabled|log_path' cowrie-env/etc/cowrie/cowrie.cfg
```
Vous devriez voir une sortie reflétant vos modifications, confirmant que la configuration a été enregistrée correctement.

Démarrer le service SSH

Dans cette étape, vous allez démarrer le service SSH du honeypot Cowrie qui écoutera les connexions entrantes. Étant donné que nous exécutons dans un conteneur Docker sans systemd, nous utiliserons l'exécution directe de processus. Cette approche est plus simple que la gestion traditionnelle de services et mieux adaptée aux environnements conteneurisés.

Tout d'abord, assurez-vous d'être dans le bon répertoire et activez l'environnement virtuel. L'environnement virtuel contient toutes les dépendances Python nécessaires isolées de votre système :
```
cd ~/project
source cowrie-env/bin/activate
```
Démarrez le service Cowrie en arrière-plan. Le flag -n le fait fonctionner en mode non-démon (affichant la sortie directement dans le terminal), tandis que & met le processus en arrière-plan pour que vous puissiez continuer à utiliser le terminal :
```
cowrie start -n &
```
Vérifiez que le service est en cours d'exécution en vérifiant la liste des processus. Cette commande filtre tous les processus en cours d'exécution pour n'afficher que ceux contenant "cowrie" :
```
ps aux | grep cowrie
```
Vous devriez voir une sortie similaire à :
```
labex   12345  0.0  0.5  12345  6789 ?        S    12:34   0:00 python cowrie start -n
```
Vérifiez si le service écoute sur le port 22. Cela est crucial car les connexions SSH arriveront sur ce port. La commande affiche tous les services réseau et les ports sur lesquels ils écoutent :
```
sudo netstat -tulnp | grep 22
```
Vous devriez voir une sortie indiquant que Python écoute sur le port 22.
Pour rendre le service persistant entre les sessions terminal, créez un simple script de maintenance. Cela garantit que le honeypot continue de fonctionner même si vous fermez votre terminal :
```
nano cowrie-keepalive.sh
```
Ajoutez le contenu suivant :
```
#!/bin/bash
source ~/project/cowrie-env/bin/activate
cowrie start -n
```
Rendez le script exécutable pour qu'il puisse être exécuté directement :
```
chmod +x cowrie-keepalive.sh
```
Vous pouvez maintenant exécuter le honeypot en exécutant ce script. Il activera l'environnement et démarrera Cowrie en une seule étape :
```
./cowrie-keepalive.sh
```

Simuler une attaque

Dans cette étape, vous allez simuler une attaque de force brute SSH contre votre honeypot Cowrie pour vérifier ses capacités de journalisation. Cette simulation permet de montrer comment les attaquants du monde réel pourraient tenter d'obtenir un accès non autorisé et comment le honeypot enregistre ces tentatives pour analyse.

Tout d'abord, assurez-vous que votre honeypot Cowrie est en cours d'exécution (étape précédente) :
```
ps aux | grep cowrie
```
Cette commande vérifie si le processus Cowrie est actif. Vous devriez voir 'cowrie' dans la liste de sortie.
Installez le client SSH s'il n'est pas déjà disponible :
```
sudo apt-get install -y openssh-client
```
Le paquet openssh-client fournit la commande ssh que nous utiliserons pour nous connecter à notre honeypot. Le flag '-y' confirme automatiquement toutes les invitations.
Simulez une attaque de force brute en tentant plusieurs connexions SSH avec des combinaisons courantes de noms d'utilisateur/mot de passe :
```
for i in {1..5}; do
  sshpass -p 'password' ssh -o StrictHostKeyChecking=no -p 22 labex@localhost
  sshpass -p 'admin' ssh -o StrictHostKeyChecking=no -p 22 admin@localhost
  sshpass -p 'root' ssh -o StrictHostKeyChecking=no -p 22 root@localhost
done
```
Ce script essaie des paires courantes de noms d'utilisateur/mot de passe (comme root/password) cinq fois chacune. L'option '-o StrictHostKeyChecking=no' empêche SSH de poser des questions sur les hôtes inconnus, facilitant ainsi l'automatisation.
Simulez une attaque plus sophistiquée en utilisant Hydra (préinstallé dans la machine virtuelle LabEx) :
```
hydra -L /usr/share/wordlists/metasploit/unix_users.txt -P /usr/share/wordlists/metasploit/unix_passwords.txt -t 4 -vV localhost ssh
```
Hydra est un outil de force brute puissant. Ici, il essaie les combinaisons des listes de mots fournies (-L pour les noms d'utilisateur, -P pour les mots de passe). L'option '-t 4' limite à 4 tentatives parallèles, et '-vV' affiche une sortie détaillée.
Vérifiez que les attaques ont été enregistrées en vérifiant les journaux Cowrie :
```
ls -l ~/project/cowrie-logs/
```
Après avoir exécuté les attaques, cette commande affiche de nouveaux fichiers de journal contenant les détails de toutes les tentatives de connexion. Ce sont ces journaux que les analystes en sécurité examineraient dans un déploiement réel.

Vérifier les journaux d'attaque

Dans cette étape, vous allez analyser les journaux d'attaque générés par Cowrie pour comprendre les attaques simulées de l'étape précédente. Les journaux contiennent des informations de sécurité précieuses sur les tentatives d'attaque. Cowrie enregistre automatiquement toutes les tentatives d'interaction dans deux formats : un journal texte simple pour une lecture rapide et un journal JSON structuré pour une analyse détaillée.

Tout d'abord, accédez au répertoire des journaux où Cowrie stocke tous ses fichiers de journal :
```
cd ~/project/cowrie-logs
```
Affichez le fichier de journal basé sur du texte (le plus récent en premier). La commande ls -lt affiche les fichiers triés par date de modification, tandis que tail affiche les 20 dernières lignes du journal le plus récent :
```
ls -lt cowrie.log*
tail -n 20 cowrie.log
```
Vous devriez voir des entrées montrant les tentatives de connexion échouées avec des horodatages, des noms d'utilisateur et des adresses IP.
Examinez le fichier de journal JSON pour obtenir des données structurées. L'outil jq permet de parser le JSON, et less permet de faire défiler une sortie longue :
```
jq '.' cowrie.json | less
```
Recherchez les entrées avec "eventid": "cowrie.login.failed" qui indiquent des tentatives d'authentification infructueuses.
Recherchez des motifs d'attaque spécifiques ciblant les comptes d'administration courants. La commande grep recherche des motifs de texte dans les fichiers :
```
grep -a "root" cowrie.log
grep -a "admin" cowrie.log
```

Générez un résumé des tentatives d'attaque. Ces commandes extraient et comptent les noms d'utilisateur et les mots de passe les plus fréquemment essayés à partir des journaux JSON :

echo "Top usernames attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .username' cowrie.json | sort | uniq -c | sort -nr

echo -e "\nTop passwords attempted:"
jq -r 'select(.eventid=="cowrie.login.failed") | .password' cowrie.json | sort | uniq -c | sort -nr

Affichez les informations sur l'adresse IP source (affichera localhost dans cette simulation). Cela extrait les adresses IP des clients se connectant :
```
jq -r 'select(.eventid=="cowrie.session.connect") | .src_ip' cowrie.json
```

Résumé

Dans ce laboratoire, vous avez appris à déployer un honeypot SSH Cowrie pour surveiller et analyser les attaques cybernétiques. Le processus a inclus la configuration d'un environnement virtuel Python, la configuration des ports SSH et l'activation de la journalisation JSON pour une collecte détaillée des données d'attaque.

Vous avez également acquis une expérience pratique en démarrant le service honeypot, en simulant des attaques et en analysant les données enregistrées. Cette activité pratique a démontré comment les outils de sécurité peuvent imiter des systèmes réels pour détecter et étudier efficacement les activités malveillantes.