Diamorphine, Reptile y Suterusu: Los Rootkits Linux que Debes Estudiar

Tres rootkits, tres filosofías

Estos tres rootkits representan tres enfoques diferentes del mismo problema: cómo ocultar actividad maliciosa en un sistema Linux comprometido.

Diamorphine es el rootkit minimalista: hace pocas cosas pero las hace bien. Menos de 300 líneas de código. Ideal para entender los fundamentos del hooking de syscalls en el kernel Linux.

Reptile es el rootkit completo: incluye todo lo que un atacante necesita (ocultación, backdoor, persistencia, port knocking). Es el "Cobalt Strike de los rootkits Linux".

Suterusu es el rootkit técnicamente avanzado: usa hooking de VFS (Virtual File System) en vez de la sys_call_table, una técnica más sigilosa y más difícil de detectar.

Diamorphine

Perfil

Atributo	Detalle
GitHub	m0nad/Diamorphine
Lenguaje	C (kernel module)
Tamaño	Menos de 300 líneas de código
Kernels soportados	2.6.x a 6.x (mantenido activamente)
Licencia	GPL
Uso en ataques reales	Documentado por CrowdStrike, Trend Micro

Capacidades

Capacidad	Mecanismo	Activación
Ocultar archivos/directorios	Hook de getdents/getdents64	Archivos que empiezan con prefijo configurable
Ocultar procesos	Hook de getdents en /proc	Enviar señal 31 al proceso
Otorgar root a un proceso	Hook de kill	Enviar señal 64 al proceso
Auto-ocultarse/revelarse	Manipulación de module list	Enviar señal 63 al proceso (toggle)
Ocultar de lsmod	Eliminación de list entry	Automático al cargar

Señales mágicas

Diamorphine usa señales Unix como interfaz de control:

Señal	Efecto
kill -31 [PID]	Toggle visibilidad del proceso (ocultar/mostrar)
kill -63 [PID]	Toggle visibilidad del módulo del kernel
kill -64 [PID]	Otorgar privilegios root al proceso

Estas señales (31, 63, 64) no son señales estándar de Unix, por lo que no interfieren con operaciones normales.

Técnica de hooking

Diamorphine localiza la sys_call_table escaneando memoria del kernel y hookea getdents y getdents64:

// Simplificado del codigo real de Diamorphine
// Hook de getdents64 para filtrar entradas de directorio
asmlinkage long hacked_getdents64(unsigned int fd,
    struct linux_dirent64 __user *dirent, unsigned int count)
{
    long ret = orig_getdents64(fd, dirent, count);
    // ... iterar por las entradas
    // Si el nombre empieza con MAGIC_PREFIX: eliminar la entrada
    // Si es un PID oculto en /proc: eliminar la entrada
    return ret;
}

Compilación

git clone https://github.com/m0nad/Diamorphine
cd Diamorphine
make
# Genera diamorphine.ko

# Cargar (requiere root)
insmod diamorphine.ko

# El modulo se auto-oculta inmediatamente
lsmod | grep diamorphine   # No aparece

Detección

# 1. Buscar en memoria del kernel
cat /proc/kallsyms | grep diamorphine
# Si hay simbolos de diamorphine: rootkit cargado

# 2. Verificar sys_call_table
# Comparar punteros de syscalls con los esperados

# 3. Volatility
vol3 -f memory.lime linux.hidden_modules
vol3 -f memory.lime linux.check_syscall

# 4. Buscar señales inusuales
# Monitorizar uso de kill con señales 31, 63, 64
# (auditd puede registrar esto)

Reptile

Perfil

Atributo	Detalle
GitHub	f0rb1dd3n/Reptile
Lenguaje	C (kernel module + userland tools)
Tamaño	~2000 líneas kernel + herramientas userland
Kernels soportados	2.6.x a 5.x+
Licencia	GPL
Uso en ataques reales	Documentado por múltiples vendors

Capacidades

Reptile incluye todo lo de Diamorphine y mucho más:

Capacidad	Descripción
Ocultar archivos/directorios	Prefijo configurable (default: reptile)
Ocultar procesos	Por PID o nombre
Ocultar conexiones de red	Filtra /proc/net/tcp, /proc/net/tcp6, /proc/net/udp
Ocultar el módulo	Auto-ocultación de lsmod y /proc/modules
Backdoor de red	Shell reverso activado por magic packet
Port knocking	Secuencia de puertos para activar el backdoor
Persistencia	Se reinstala automáticamente al reiniciar
Otorgar root	Comando desde userland
Ocultar de iptables	Filtra reglas de iptables que podrían bloquear el backdoor

Backdoor de red

Reptile incluye un backdoor de red basado en magic packets:

1. Reptile escucha TODO el tráfico de red a nivel de kernel (no necesita un socket)
2. Cuando detecta un paquete con un "magic byte" específico, activa el backdoor
3. El backdoor establece una conexión reversa (reverse shell) al IP del paquete mágico
4. La conexión no aparece en netstat/ss porque el rootkit la oculta

Atacante envía magic packet → Reptile lo detecta → Shell reverso al atacante
                                                     (invisible para el admin)

Port knocking

Alternativa al magic packet: el atacante envía paquetes a una secuencia de puertos. Cuando la secuencia es correcta, Reptile activa el backdoor:

Atacante: SYN a puerto 1234 → SYN a puerto 5678 → SYN a puerto 9012
Reptile detecta la secuencia → Activa backdoor → Shell reverso

Los paquetes de port knocking no generan respuesta (los puertos no están "abiertos"), por lo que son invisibles para herramientas de escaneo como nmap.

Instalación

git clone https://github.com/f0rb1dd3n/Reptile
cd Reptile
# Configurar (magic bytes, puertos, passwords)
./setup.sh
# Compilar e instalar
make
make install

Detección de Reptile

# 1. Buscar archivos con prefijo "reptile"
find / -name "*reptile*" 2>/dev/null

# 2. Buscar el directorio oculto de Reptile
ls -la /reptile/  # Podria estar oculto por el rootkit
# Alternativa: acceder directamente
cat /reptile/reptile_cmd 2>/dev/null

# 3. Buscar en memoria del kernel
cat /proc/kallsyms | grep reptile

# 4. Verificar modulos ocultos
# Comparar /proc/modules con /sys/module/
ls /sys/module/ > sysmod.txt
cat /proc/modules | awk '{print $1}' > procmod.txt
diff sysmod.txt procmod.txt

# 5. Network: buscar magic packet listeners
# Dificil de detectar desde el sistema comprometido
# Analisis de trafico externo puede detectar patrones de port knocking

# 6. Volatility
vol3 -f memory.lime linux.hidden_modules

Suterusu

Perfil

Atributo	Detalle
Origen	Fork/evolución de rootkits LKM clásicos
Lenguaje	C (kernel module)
Técnica diferenciadora	VFS hooking en vez de sys_call_table
Kernels	2.6.x a 4.x
Estado	Menos mantenido que Diamorphine/Reptile

Técnica: VFS hooking

En vez de modificar la sys_call_table (que está protegida en kernels modernos), Suterusu hookea las operaciones del Virtual File System:

// En vez de hookear la syscall getdents64:
// Suterusu hookea la operacion readdir del VFS

// Cada filesystem (ext4, proc, tmpfs) tiene una estructura file_operations
// con punteros a funciones como readdir/iterate
// Suterusu modifica estos punteros en los filesystems especificos

struct file_operations *proc_fops = get_proc_fops();
original_iterate = proc_fops->iterate_shared;
proc_fops->iterate_shared = hooked_iterate;

Ventajas del VFS hooking

Aspecto	sys_call_table hooking	VFS hooking
Superficie de hook	Global (una syscall)	Por filesystem
Protecciones del kernel	cr0 write protection, KASLR	Menos protegido
Detección	Verificar sys_call_table	Verificar cada file_operations struct
Granularidad	Todas las llamadas a getdents	Solo en filesystems específicos (/proc, /)
Estabilidad	Puede causar issues si otro módulo hookea	Más estable

Capacidades

Capacidad	Implementación
Ocultar archivos	VFS hook en readdir del filesystem root
Ocultar procesos	VFS hook en readdir de /proc
Ocultar conexiones	VFS hook en read de /proc/net/*
Ocultar módulo	Manipulación de listas del kernel
Backdoor	Socket raw para recibir comandos

Comparativa de los tres rootkits

Característica	Diamorphine	Reptile	Suterusu
Líneas de código	~300	~2000+	~1000
Hooking method	sys_call_table	sys_call_table	VFS operations
Ocultar archivos	Sí (prefijo)	Sí (prefijo)	Sí
Ocultar procesos	Sí (señal)	Sí	Sí
Ocultar conexiones	No	Sí	Sí
Backdoor de red	No	Sí (magic packet + port knocking)	Básico
Persistencia	No (manual)	Sí (automática)	No (manual)
Root privilege grant	Sí (señal 64)	Sí	Sí
Mantenimiento activo	Sí	Sí	Parcial
Dificultad de detección	Media	Media-Alta	Alta (VFS hooks)
Uso educativo	Excelente (simple)	Bueno (feature-rich)	Bueno (técnica avanzada)

Detección genérica de rootkits LKM

Checklist de detección

# 1. Verificar integridad de binarios del sistema
debsums -c  # Debian/Ubuntu
rpm -Va     # RHEL/CentOS

# 2. Buscar discrepancias en listas de procesos
ls /proc | grep -E '^[0-9]+$' | sort -n > from_proc.txt
ps -eo pid --no-headers | sort -n > from_ps.txt
diff from_proc.txt from_ps.txt

# 3. Buscar modulos ocultos
ls /sys/module/ | sort > sysmod.txt
lsmod | awk '{print $1}' | sort > lsmod.txt
diff sysmod.txt lsmod.txt

# 4. Buscar hooks en sys_call_table
cat /proc/kallsyms | grep sys_call_table
# Verificar que las direcciones apuntan a funciones esperadas

# 5. Verificar /etc/ld.so.preload
cat /etc/ld.so.preload
ls -la /etc/ld.so.preload

# 6. Buscar eBPF programs
bpftool prog list
bpftool map list

# 7. Ejecutar rkhunter
rkhunter --check --skip-keypress

# 8. Ejecutar chkrootkit
chkrootkit

# 9. Buscar strings de rootkits conocidos
grep -r "diamorphine\|reptile\|suterusu" /proc/kallsyms
dmesg | grep -i rootkit

# 10. Memory forensics (mas fiable)
# Capturar con LiME, analizar con Volatility

auditd rules para detectar carga de módulos

# Detectar insmod/modprobe
-w /sbin/insmod -p x -k kernel_module_load
-w /sbin/modprobe -p x -k kernel_module_load
-w /sbin/rmmod -p x -k kernel_module_load
-a always,exit -F arch=b64 -S init_module -S finit_module -k kernel_module_load
-a always,exit -F arch=b64 -S delete_module -k kernel_module_unload

Mapeo MITRE ATT&CK

Técnica	ID	Rootkit
Rootkit	T1014	Los tres
Kernel Modules and Extensions	T1547.006	Los tres (carga via insmod)
Hide Artifacts: Hidden Files and Directories	T1564.001	Los tres
Hide Artifacts: Hidden Users	T1564.002	Los tres (procesos ocultos)
Ingress Tool Transfer	T1105	Reptile (backdoor de red)
Non-Standard Port	T1571	Reptile (port knocking)

---

Fuentes y referencias

• m0nad. "Diamorphine: LKM rootkit." https://github.com/m0nad/Diamorphine
• f0rb1dd3n. "Reptile: Linux LKM rootkit." https://github.com/f0rb1dd3n/Reptile
• CrowdStrike. "Diamorphine and Reptile in Real-World Attacks." CrowdStrike Intelligence.
• Trend Micro. "Linux Rootkits in the Wild." Trend Micro Research, 2023.
• Matrosov, A. et al. "Rootkits and Bootkits." No Starch Press, 2019.
• Love, R. "Linux Kernel Development." Addison-Wesley, 2010.
• MITRE ATT&CK. "Rootkit (T1014)." https://attack.mitre.org/techniques/T1014/
• Volatility Foundation. "Linux Rootkit Detection Plugins." Volatility 3.