Installation de Kippo sous debian

Présentation

Kippo est un honeypot à interaction moyenne, son but est d’émuler un service SSH afin d’archiver les tentatives de brute force des attaquants, mais aussi les interactions qu’ils effectuent une fois connectés.

En effet, il est possible grâce à kippo de définir un mot de passe faible afin de laisser l’attaquant avoir un shell sur la machine. Cet environnement est bien sûr protégé, mais permet à notre système de journaliser les commandes qui ont été entrées ainsi que les fichiers téléchargés.

De plus lorsque l’attaquant pense quitter le shell SSH pour revenir sur son shell local, Kippo l’amène dans un deuxième environnement protégé afin de loguer les commandes qu’il aurait pu entrer sur sa machine pour déclencher l’attaque.

Installation

Installation des dépendances

Pour fonctionner Kippo a juste besoin de Python. Néanmoins pour une installation propre, nous allons installer ses dépendances dans un environnement virtuel avec l’aide de PIP et VirtualEnv. Enfin nous allons installer la librairie MySQL clients au cas où nous voudrions nous interfacer avec une base de données MySQL.

$ sudo apt-get install build-essential python-dev libmysqlclient-dev python-virtualenv python-pip

Il s’agit de la seule commande que l’on doit exécuter en root durant l’installation.

Créer l’environnement virtuel

Il est maintenant nécessaire de créer l’environnement virtuel python que nous appellerons “kippo”. Pour celà, il faut entrer la commande suivante:

$ virtualenv kippo_venv

Puis il faut l’activer afin d’entrer dans cet environnement:

$ source kippo_venv/bin/activate

Après cette commande le shell change afin de ressembler à celui-ci:

(kippo_venv)$

Installer les dépendances Python

Maintenant que l’environnement virtuel est fonctionnel, il est possible d’installer les dépendances python du projet:

(kippo_venv)$ pip install twisted==15 pyasn1 pycrypto

Installation de Kippo

Après avoir installé les dépendances de kippo, il suffit maintenant de le télécharger grâce à git :

(kippo_venv)$ git clone https://github.com/desaster/kippo.git

Configuration de Kippo

La configuration de kippo se situe dans kippo.cfg, Par défaut ce fichier n’existe pas, mais un template est fourni avec une configuration basique, il suffit donc simplement de la copier sous un autre nom:

(kippo_venv)$ cd kippo
(kippo_venv)$ cp kippo.cfg.dist kippo.cfg

Il est aussi possible de créer différents utilisateur dans le fichier data/userdb.txt.

Enfin, il est déconseillé de lancer kippo sur le port 22. En effet sous GNU/Linux tous les ports en dessous de 1024 sont des ports réservés nécessitant des droits privilégiés. Il est donc conseillé de laisser le port 2222 par défaut et d’effectuer du NAT afin de rediriger le port 22 vers le port 2222 de la machine. Si kippo est exécuté sous Windows, il est tout à fait possible de mettre le port 22 qui est habituellement libre.

Rediriger le port 22 vers le port 2222

La configuration du port forwarding se fait via une simple règle IPTables:

$ sudo iptables -t nat -A PREROUTING -p tcp --dport 22 -j REDIRECT --to-port 2222

Utilisation

Kippo peut se lancer de deux manières, soit en arrière-plan, soit au premier plan.

Lancement de Kippo au premier plan

Tout d’abord, pour lancer kippo

(kippo)$ twistd -n -y kippo.tac

Lancement de Kippo au arrière-plan

Contrairement au lancement précédent, celui-ci ne nécessite pas que l’utilisateur soit connecté à l’environnement virtuel. Le script de lancement prend tout simplement le nom de l’environnement en argument:

$ ./start.sh kippo_venv

L’arrêt du logiciel se fera via l’exécution du script stop.sh.

Port Knocking et installation de Knockd sous debian

Le port no quoi ?

Le port knocking est un système permettant de débloquer les port d’une machine en fonction d’une suite de «knock» reçu sur certains ports. De ce fait, il est possible d’ouvrir un port ssh qu’après avoir reçu un knock sur le port 3000 et 8000, voir même de demander un knock de type TCP et l’autre de type UDP. Un knock est représenter par une trame TCP ou UDP visant un port particulier du système

Installation de port knocking sous debian

Présentation

knockd est un daemon permettant de faire du port knocking sous Linux. Le service surveille toutes les connexions entrantes sur les interfaces de la machine, si les connexions consécutives correspondent à une séquence de «knocks» qu’il a dans sa configuration, alors il execute une commande permettant d’ouvrir un port.

Installation

Pour installer knockd sous debian c’est très simple. Celui-ci est disponible dans les paquets de Debian Wheezy et peut donc être installé avec la commande suivante:

apt-get install knockd

Après avoir installer knockd, il est neccessaire de modifier le fichier de configuration /etc/default/knockd pour lui donner l’autorisation de démarrer. Pour celà, il suffit de modifier la ligne suivante:

# Avant
START_KNOCKD=0
# Après
START_KNOCKD=1

Configuration de knockd

Nous allons maintenant configuer knockd pour ouvrir le port 22 (ssh) lorsque des knocks sont détectés sur les ports 7000, 8000 et 9000 en TCP. Nous allons donc modifier le fichier /etc/knockd.conf et lui appliquer la configuration suivante.

[opencloseSSH]
        sequence    = 7000,8000,9000
        seq_timeout = 5
        start_command     = /sbin/iptables -I INPUT 1 -s %IP% -p tcp --dport 22 -j ACCEPT
        tcpflags    = syn
        cmd_timeout   = 10
        stop_command  = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT

Nous demandons donc à knockd d’ouvrir le port en rajoutant une règles iptables quand les knocks correspondent. Nous lui demandons aussi de refermer ce port au bout de 10 secondes. Par défaut les ports indiqué doivent être «knocké» en TCP, mais il est aussi possible de demander de l’UDP. Pour ça il suffit d’indiquer le port suivant de son protocôle de la manière suivante: num_port:protcole.

Nous pouvons maintenant démarrer knockd:

service knockd start

Configuration iptables

Nous allons maintenant définir quelques règles iptables pour profiter de knockd. En effet, de base, debian ne définis aucune règle de filtrage. Tout les ports sont donc ouvert par défaut. Nous allons donc définir des règles permettant de laisser passer certaines trames comme celle transitant sur notre boucle locale. Puis nous demanderons à iptables de droper tout les paquets en dernier recours:

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -j DROP

Ouvrir le port à distance

Pour éxecuter une suite de knock rien de plus simple. Il y a même plusieurs solutions pour le faire.

Le client knock

Lorsque l’on installe le serveur de port knocking «knockd», un client est automatiquement installé avec. Il se nomme subtilement knock. Pour l’utiliser rien de plus simple:

knock ip_server 7000 8000 9000

Et par exemple si le port 8000 doit être «knocké» en UDP:

knock ip_server 7000 8000:udp 9000

NMAP

Il est aussi d’utiliser le scanner de port NMAP pour effectuer des knocks:

nmap -Pn --host_timeout 201 --max-retries 0  -p 7000 ip_server
nmap -Pn --host_timeout 201 --max-retries 0  -p 8000 ip_server
nmap -Pn --host_timeout 201 --max-retries 0  -p 9000 ip_server

Conclusion

Comme vous pouvez le voir knockd est très simple à mettre en place. Pensez tout de même à prendre votre temps sur la rédaction de vos règles iptables, ça serait balot de perdre la main sur votre machine distante pendant la configuration ;)