Rootpacket: un toolkit de cryptojacking para Linux que se oculta en el kernel

TLP:CLEAR. Autorizado para divulgación pública. Capturado por la red de sensores honeypot de Kinryū Labs. Los indicadores que figuran a continuación están desactivados (defanged).

Resumen ejecutivo

• ~45%de CPU que muestra top mientras se ejecuta cerca del 100%
• 3mecanismos de persistencia
• 7.8CVSS, CVE-2026-31431 (LPE por page cache en AF_ALG)
• hostroot desde un contenedor sin privilegios

Rootpacket es un toolkit de cryptojacking multicomponente para Linux. Incluye un rootkit a nivel de kernel para operar de forma sigilosa, un exploit de escalada de privilegios para CVE-2026-31431 en la interfaz criptográfica AF_ALG de Linux, un minero de Monero XMRig 6.26.0 empaquetado con UPX y renombrado como xrandom, y un script de eliminación de competidores. El código está escrito en gran parte en turco (nombres de variables, comentarios, cadenas de estado), lo que apunta a un operador turcohablante.

El toolkit funciona en uno de dos modos. En modo root carga un rootkit en forma de módulo de kernel cargable (LKM) disfrazado de intel_uncore_freq_aux, lo instala a través de DKMS para que sobreviva a las actualizaciones del kernel, registra un servicio systemd y limpia la máquina de rivales. Cuando no logra obtener root, recurre a un modo en espacio de usuario que persiste mediante crontab y ejecuta el minero como demonio. El minero se conecta a pool.supportxmr.com:443 sobre stratum+ssl y mina Monero con RandomX.

El componente que merece atención es el rootkit. Mientras el minero mantiene el procesador cerca del 100 por ciento, el rootkit reescribe /proc/stat para que top y htop informen un tranquilo 40 a 50 por ciento, y hace oscilar esa cifra usando jiffies para que la carga parezca real en lugar de quedar fija en un valor constante. Hace lo mismo con /proc/meminfo y filtra los listados de directorios para ocultar sus propios procesos y archivos.

Arquitectura del toolkit

Rootpacket es un dropper modular. Las piezas:

setup.sh         Entry point. Checks privilege level, picks a deployment mode.
getroot          Privilege escalation. Exploits CVE-2026-31431 (AF_ALG) for local root.
xrandom          UPX-packed XMRig 6.26.0, renamed to dodge name-based detection.
kernel/
  stealth.c      LKM rootkit, compiled via DKMS, disguised as an Intel driver.
  install.sh     DKMS persistence engine.
killservice.sh   Competitor elimination and "hardening".
rootpacket.tar.gz  An inner copy of the whole toolkit, packaged for redistribution.

Modo root. setup.sh ejecuta getroot si no es ya root, copia xrandom a /opt/kernel-kd/, crea un servicio systemd, ejecuta kernel/install.sh para compilar y cargar el rootkit mediante DKMS, ejecuta killservice.sh para eliminar a la competencia e inicia el minero como servicio persistente.

Alternativa en espacio de usuario. Cuando root queda fuera de alcance, setup.sh copia xrandom a ~/.xrandom/, escribe un lanzador con un bloqueo por PID, instala una entrada de crontab que se dispara en el arranque y cada minuto, y lanza el minero con setsid para que sobreviva al shell padre.

Característica	Modo root	Modo en espacio de usuario
Ubicación del minero	/opt/kernel-kd/xrandom	~/.xrandom/xrandom
Persistencia	systemd (kernel-kd.service)	crontab (@reboot + */1 * * * *)
Rootkit	Sí (LKM vía DKMS)	No
Eliminación de competidores	Sí (killservice.sh)	No
Se ejecuta como	root (systemd)	usuario actual (demonio con setsid)

getroot: CVE-2026-31431, root por corrupción del page cache

getroot es un binario ELF64 x86-64 enlazado estáticamente y sin strip, construido a partir de getroot.c. Explota CVE-2026-31431 (“Copy Fail”), un fallo de lógica en la interfaz algif_aead de AF_ALG del kernel de Linux divulgado el 29 de abril de 2026 (CVSS 7.8). El bug concede una escritura determinista de 4 bytes controlada por el atacante en el page cache del kernel, y getroot la usa para parchear un binario SUID en memoria y salir con privilegios de root.

Propiedad	Valor
Tipo	Ejecutable ELF 64-bit LSB, x86-64, enlazado estáticamente, sin strip
CVE	CVE-2026-31431 “Copy Fail” (CVSS 7.8, AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
Subsistema	algif_aead de AF_ALG, plantilla AEAD authencesn(hmac(sha256),cbc(aes))
Afectados	Linux 4.14 a 6.19.11 (el fallo se introdujo en 2017, commit 72548b093ee3); corregido en 6.18.22, 6.19.12, 7.0+
Objetivo	/usr/bin/su: su .text en memoria se parchea en el page cache
Fiabilidad	Determinista, sin condición de carrera
Uso / alternativa	./getroot <cmd> [args...]; si el exploit no funciona, ejecuta el comando con los privilegios actuales de todos modos

El mecanismo. Una optimización in-place de 2017 en el código AEAD dejó las páginas del page cache obtenidas con splice presentes tanto en la scatterlist de origen como en la de destino. Cuando la plantilla authencesn escribe su valor temporal ESN de 4 bytes en el desplazamiento elegido por el atacante assoclen + cryptlen, esa escritura cae dentro de la página del page cache de un archivo legible por el usuario. La comprobación HMAC falla entonces y recvmsg() devuelve EBADMSG, pero el kernel nunca revierte la escritura. getroot analiza las cabeceras ELF de /usr/bin/su para calcular el desplazamiento en el archivo de su punto de entrada, y después itera splice → sendmsg (con los 4 bytes a escribir en el AAD) → recvmsg, una vez por cada fragmento de 4 bytes del shellcode, parcheando /usr/bin/su en el page cache. A continuación hace execve de /usr/bin/su: el kernel carga la página ya corrupta, el shellcode se ejecuta con SUID root, y getroot confirma getuid() == 0 antes de ejecutar el comando del operador (imprimiendo el mensaje en turco [+] ROOT ele gecirildi!). El archivo en disco nunca se modifica, por lo que la monitorización de integridad de archivos no ve nada.

Escape del contenedor hacia el host. El page cache de Linux es global al host; los contenedores no tienen el suyo propio. Un proceso dentro de un contenedor sin privilegios que haga splice del /usr/bin/su del host corrompe la copia en caché del host, de modo que el execve otorga root en el host, no solo en el contenedor. Por lo tanto, un contenedor infectado es un host comprometido, y setup.sh continúa cargando el rootkit de kernel en el host. Detener y eliminar el contenedor no es suficiente; hay que reconstruir el host.

Ejecutamos getroot una vez en una máquina virtual aislada (Kali, kernel 6.6.15). Realizó la secuencia AF_ALG completa pero no obtuvo root en esa compilación y recurrió a ejecutar el comando sin privilegios, lo que concuerda con un exploit dirigido a disposiciones de kernel concretas. No ejecutamos el minero.

xrandom: el minero

xrandom es una copia renombrada y empaquetada con UPX de XMRig 6.26.0, el minero de Monero de código abierto.

Propiedad	Valor
Identidad real	XMRig 6.26.0
Empaquetado	UPX 4.2.4 (2.8 MB empaquetado, 10.1 MB desempaquetado)
Algoritmo	RandomX (rx/0)
Pool	pool.supportxmr.com:443 sobre stratum+ssl
Cartera	46NVDFL6v5STw5Qw4j77PoBSHRTYnHZGZ8WRoGvHmpaMX7ZyhNUP2u24TLV9pNgncz1bZF2Vm8KkaNTzU7SXqrnFUx5zgHQ
Nivel de donación	0 (donación al desarrollador de XMRig desactivada)

Minar por el puerto 443 con TLS permite que el tráfico se mezcle a primera vista con HTTPS corriente, aunque el handshake de stratum tiene una huella TLS distinta para quien mire con atención.

stealth.c: el rootkit de kernel

Esta es la parte más desarrollada del toolkit. Es un rootkit LKM que usa el hooking de funciones mediante ftrace para interceptar funciones del kernel y borrar el rastro del malware, y que se hace pasar en todo momento por un controlador de hardware de Intel.

Propiedad	Valor
Nombre del módulo	intel_uncore_freq_aux
Metadatos falsos	MODULE_AUTHOR("Intel Corporation"), MODULE_DESCRIPTION("Intel Uncore Frequency Control Driver"), MODULE_VERSION("1.2.0")
Hooking	ftrace mediante kallsyms_lookup_name (resuelto con un kprobe en kernels 5.7 y posteriores)
Control	sysfs en /sys/kernel/intel_uncore_freq/ (enabled, cpu_lo, cpu_hi, mem_lo, mem_hi, hide_tag)

Qué intercepta y por qué:

• Enmascaramiento de CPU. Intercepta show_stat para reescribir /proc/stat, falseando la utilización entre límites configurables (40 a 50 por ciento por defecto) y oscilando con jiffies para que el número se mueva como una carga real en lugar de quedarse plano.
• Enmascaramiento de memoria. Intercepta meminfo_proc_show para reescribir /proc/meminfo, falseando MemFree, MemAvailable, Buffers, Cached, Active e Inactive.
• Ocultación de procesos. Intercepta iterate_dir para filtrar los listados de /proc, ocultando los PID cuyos nombres coinciden con un conjunto fijo en el código: stealth, masscan, sshruns, ransomx, cpumask, xrandom, cpm_, kcpm, mask_helper, ftrhook, kintel_aux. Un operador puede añadir más nombres en tiempo de ejecución a través de /sys/kernel/intel_uncore_freq/hide_tag.
• Ocultación de archivos. Oculta las rutas que coinciden con stealth, cpumask, kintel_aux, intel_uncore_freq_aux y el propio directorio de sysfs.
• Autoocultación. Al cargarse se elimina de /proc/modules y de /sys/module/ con list_del_init, borra su kobject de sysfs e incrementa su propio contador de referencias con try_module_get para que rmmod no pueda descargarlo.

Esa lista de ocultación también es un indicio: junto al minero oculta masscan, sshruns y ransomx, por lo que es probable que el operador esté ejecutando un escáner y puede que tenga algo más que un minero en el kit.

El efecto práctico es que un administrador que observe top ve una máquina ocupada pero normal, no encuentra ningún proceso sospechoso y no puede ver el módulo de kernel que está mintiendo. Los indicios son físicos y fuera de banda: la máquina se calienta, los ventiladores se aceleran y el consumo eléctrico sube, y nada de eso puede falsearlo el rootkit.

Persistencia: tres mecanismos, divididos por modo

La persistencia de Rootpacket depende del modo en el que aterrice. En modo root superpone dos mecanismos que se refuerzan mutuamente; en modo de espacio de usuario recurre a un tercero.

#	Mecanismo	Modo	Detalle
1	Servicio systemd	root	kernel-kd.service, Type=simple, Restart=always, RestartSec=3
2	Módulo DKMS	root	Instala el rootkit en /lib/modules/$(uname -r)/extra/; sobrevive a las actualizaciones del kernel
3	crontab	usuario	@reboot más cada minuto (* * * * *), con un bloqueo por PID y setsid

La entrada de DKMS es la más tenaz: instala el rootkit a través del propio sistema de compilación de módulos del kernel, de modo que una actualización rutinaria del kernel lo recompila y lo rearma en lugar de eliminarlo.

killservice.sh: limpiar y cerrar la máquina

El script se presenta en su banner como “cryptojacker hardening”, y esa descripción es exacta desde el punto de vista del operador. Funciona en tres fases.

Fase 1: apagar los servicios expuestos. Apunta a servicios que escuchan en 0.0.0.0 y que son puntos de entrada habituales del cryptojacking: detiene, desactiva y enmascara cada uno, aplica chmod 000 a los binarios y añade reglas DROP de iptables:

Servicio	Puerto
Redis	6379
Docker	2375/2376
PostgreSQL	5432
MongoDB	27017
Elasticsearch	9200/9300
Memcached	11211
Hadoop YARN	8088
Jenkins	8080
Confluence	8090

La línea de Docker es el tejido que conecta con nuestro informe sobre RedTail: Rootpacket cierra exactamente la puerta 2375/2376 por la que entra RedTail. Un operador que llega primero mina el host y después deja fuera al siguiente grupo, endureciendo la máquina contra las técnicas que ellos habrían usado.

Fase 2: eliminar mineros rivales. Mata procesos, borra archivos, limpia tareas cron y purga claves SSH asociadas a familias conocidas de cryptojacking, entre ellas XMRig, Kinsing (kdevtmpfsi), TeamTNT (tntrecht, mdrfckr), sustes, watchdogs y minerd, junto con escáneres como masscan, pnscan y zgrab.

Fase 3: eliminar rootkits de espacio de usuario. Quita de /etc/ld.so.preload las entradas LD_PRELOAD maliciosas conocidas (libprocesshider.so, libjdk.so, libpamx.so, una libselinux.so.3 falsa y xhide) y borra las bibliotecas, limpiando los rootkits de espacio de usuario de la competencia que pudieran interferir con el suyo.

Atribución

Los nombres de variables, comentarios y cadenas de estado en turco del toolkit (por ejemplo ROOT ele gecirildi!, “root obtenido”) apuntan con confianza moderada a un operador turcohablante. Encontramos una URL de distribución o staging en linuxutil5.pages[.]dev, alojada en Cloudflare Pages, lo que encaja con el patrón de alojar payloads en infraestructura gratuita y de buena reputación para pasar desapercibido. El rootpacket.tar.gz interno, una copia autocontenida de todo el toolkit, le da al operador un paquete listo para enviar al siguiente host.

Indicadores de compromiso

Red

Indicador	Contexto
pool.supportxmr.com / pool.supportxmr.com:443	Pool principal de minado de Monero, stratum+ssl
linuxutil5.pages[.]dev	Distribución / staging (Cloudflare Pages)
api.xmrig.com, randomx.xmrig.com:443	Endpoints de API y benchmark de XMRig
donate.v2.xmrig.com, donate.ssl.xmrig.com	Pools de donación al desarrollador de XMRig (presentes, donación desactivada)
stratum+ssl:// al puerto 443	Tráfico TLS de minado saliente

Cartera de Monero: 46NVDFL6v5STw5Qw4j77PoBSHRTYnHZGZ8WRoGvHmpaMX7ZyhNUP2u24TLV9pNgncz1bZF2Vm8KkaNTzU7SXqrnFUx5zgHQ

Archivos (SHA-256)

Archivo	SHA-256	MD5
rootpacket.tar.gz (externo)	e2d0dab6b29df89d123fe8581047a03ac9b89ae8fa0d1f334b5aefbb93152857
getroot	dda96d8a4bcc39dc7679347a4386bf1024152d2ccc46d333725ad0cda855d952
xrandom (empaquetado)	ec3ef3dce99fa6cbc480f0f0b0c292676afed68704c44396271c7dc6afea2937

Build IDs: getroot 148d8d902efd93ed892a541972fbcea3a99d05a3, xrandom d7a91225bdd2e3ab67cabded9d7809bcc724401f.

Artefactos en el host

Ruta	Contexto
/opt/kernel-kd/xrandom	Binario del minero (modo root)
~/.xrandom/xrandom, ~/.xrandom/run.sh	Minero y lanzador (modo de espacio de usuario)
/tmp/.xrandom.lock	Bloqueo por PID (modo de espacio de usuario)
/etc/systemd/system/kernel-kd.service	Unidad systemd maliciosa
/usr/src/intel_uncore_freq_aux-1.2.0/	Código fuente DKMS del rootkit
/sys/kernel/intel_uncore_freq/	Interfaz de control del rootkit en sysfs
/lib/modules/*/extra/intel_uncore_freq_aux.ko	Módulo del rootkit compilado

Comportamiento

• Un proceso llamado xrandom ejecutándose como root o como el usuario actual.
• Cifras de CPU en /proc/stat que no coinciden con los contadores de rendimiento del hardware (perf stat), o con la velocidad de los ventiladores y el consumo eléctrico.
• Un servicio systemd kernel-kd (habilitado, Type=simple, Restart=always).
• Una entrada de cron etiquetada con # xrandom-userland-autostart.
• Un módulo de kernel intel_uncore_freq_aux que se carga en el arranque pero no aparece en lsmod.

Detección

Si el rootkit no está cargado

systemctl status kernel-kd.service
ls -la /opt/kernel-kd/ ~/.xrandom/
dkms status | grep intel_uncore_freq
crontab -l | grep xrandom
lsmod | grep intel_uncore

Si el rootkit está cargado

Las vistas desde el espacio de usuario están comprometidas, por lo que la detección tiene que venir desde debajo o desde al lado del rootkit:

• Compara la CPU de /proc/stat con los contadores de hardware mediante perf stat. Una diferencia grande es el indicio.
• Busca hooks de ftrace sobre show_stat, meminfo_proc_show e iterate_dir.
• Trata una discrepancia entre la CPU reportada y el consumo, el calor o la velocidad de los ventiladores reales como una señal fuerte.

Detectar la escalada de privilegios

• Un socket AF_ALG, SOCK_SEQPACKET abierto por un proceso que no es una herramienta criptográfica conocida (cryptsetup, openssl, gpg, systemd-cryptsetup) es el indicio principal. El orden completo es socket(AF_ALG) → bind → setsockopt(SOL_ALG) → accept → pipe → splice → sendmsg → splice → recvmsg (repetido), y después execve(/usr/bin/su).
• Compara los bytes en disco de cada binario SUID con su vista en el page cache. sha256sum lee a través de la caché y muestra la copia corrupta, así que lee el disco directamente con dd if=<file> iflag=direct, calcula el hash de eso y haz la comparación. Una discrepancia en un binario SUID es corrupción del page cache.

YARA candidata

rule Rootpacket_Cryptojacker
{
    meta:
        description = "Rootpacket Linux cryptojacking toolkit"
        reference   = "Kinryu Labs CTI 2026-06-16"
    strings:
        $wallet = "46NVDFL6v5STw5Qw4j77PoBSHRTYnHZGZ8WRoGvHmpaMX7ZyhNUP2u24TLV9pNgncz1bZF2Vm8KkaNTzU7SXqrnFUx5zgHQ" ascii
        $svc    = "kernel-kd" ascii
        $cron   = "xrandom-userland-autostart" ascii
        $mod    = "intel_uncore_freq_aux" ascii
    condition:
        $wallet or 2 of ($svc, $cron, $mod)
}

Remediación

1. Elimina el rootkit desde un estado que se sepa limpio. Arranca desde un medio live o de recuperación. Borra /lib/modules/*/extra/intel_uncore_freq_aux.ko* y ejecuta dkms remove intel_uncore_freq_aux/1.2.0 --all, después borra /usr/src/intel_uncore_freq_aux-1.2.0/ y reconstruye el initramfs (update-initramfs -u, dracut -f o mkinitcpio -P). La entrada de DKMS tiene que desaparecer o se recompilará.
2. Elimina el servicio: systemctl stop kernel-kd; systemctl disable kernel-kd; rm /etc/systemd/system/kernel-kd.service; systemctl daemon-reload.
3. Elimina el minero: rm -rf /opt/kernel-kd/ ~/.xrandom/ /tmp/.xrandom.lock, después pkill -9 -f xrandom.
4. Limpia cron de las líneas # xrandom-userland-autostart.
5. Restaura lo que killservice.sh rompió. Aplicó chmod 000 a los binarios de Redis, Docker, PostgreSQL, MongoDB y otros, y añadió reglas DROP de iptables. Reinstala los paquetes afectados y revisa el firewall.
6. Busca movimiento lateral. El rootpacket.tar.gz interno está hecho para redistribuirse, así que revisa otros hosts en busca de los mismos indicadores y revisa los registros por si hubo explotación de los servicios que figuran en killservice.sh para encontrar la vía de entrada.
7. Cierra CVE-2026-31431. Actualiza a un kernel corregido (6.18.22, 6.19.12, 7.0+, o el backport de tu distribución). Donde no puedas parchear de inmediato, desactiva la interfaz vulnerable: echo 'install algif_aead /bin/false' > /etc/modprobe.d/disable-algif-aead.conf y después rmmod algif_aead. En contenedores, bloquea AF_ALG (familia 38) en el perfil de seccomp.
8. Asume el compromiso del host desde un contenedor. Como la escritura en el page cache atraviesa la frontera del contenedor, trata cualquier host en el que se haya ejecutado setup.sh, incluso desde dentro de un contenedor, como totalmente comprometido. Reconstruye el host en lugar de limitarte a eliminar el contenedor.

Mapeo MITRE ATT&CK

Táctica	Técnica
Acceso inicial	T1190 Explotación de aplicación expuesta a internet (Redis, Docker, MongoDB, Elasticsearch, Jenkins, Hadoop YARN, implícito)
Ejecución	T1059.004 Shell de Unix
Escalada de privilegios	T1068 Explotación para escalada de privilegios (CVE-2026-31431, algif_aead de AF_ALG); T1611 Escape al host (page cache compartido)
Persistencia	T1543.002 Servicio systemd; T1053.003 Cron; T1547.006 Módulos de kernel (DKMS)
Evasión de defensas	T1014 Rootkit; T1036.005 Suplantación: coincidencia con nombre legítimo; T1027.002 Empaquetado de software (UPX); T1070.004 Borrado de archivos; T1564.001 Archivos ocultos
Descubrimiento	T1057 Descubrimiento de procesos (búsqueda de rivales)
Movimiento lateral	T1570 Transferencia lateral de herramientas (paquete interno de redistribución)
Impacto	T1496 Secuestro de recursos (minado de Monero)

Metodología y notas del analista

• El análisis fue principalmente estático (extracción de cadenas, desensamblado, revisión de código fuente, análisis estructural) sobre Kali Linux x86-64. También ejecutamos getroot una vez en una máquina virtual aislada (kernel 6.6.15) para observar su comportamiento: intentó la secuencia AF_ALG, no obtuvo root en esa compilación y recurrió a ejecutar el comando sin privilegios. El minero no se ejecutó y no se subió nada.
• El componente de escalada de privilegios es CVE-2026-31431, identificado a partir de la plantilla authencesn(hmac(sha256),cbc(aes)) asociada al socket AF_ALG, el objetivo /usr/bin/su en el page cache y el bucle de escritura splice/sendmsg/recvmsg en el binario.
• Las muestras (el toolkit y sus componentes) están disponibles para otros investigadores y defensores a petición. Escribe a [email protected] con una nota breve sobre quién eres y para qué las necesitas.