donfanning/mips-cve-2014-9222Vamos a divertirnos examinando un firmware de router Zyxel y la arquitectura MIPS
Los tutoriales son solo para fines informativos y educativos. Creo que el hacking ético, la seguridad de la información y la ciberseguridad deberían ser temas familiares para cualquier persona que utilice información digital y ordenadores. Creo que es imposible defenderse de los hackers sin saber cómo se realiza el hacking.
$ IDA Pro +7.0 (puedes usar Radar2 ya que IDA es bastante caro)
$ Router con Rompager 4.07: hay una cantidad inmensa de ellos, como TP-Link TD-W8951*, ZyXEL P-660R, Billion BiPAC 51**/52**
$ UART a USB
La vulnerabilidad de la mala suerte (misfortune cookie) ha existido durante un tiempo, pero aún carece de un análisis que ilustre los detalles técnicos de la vulnerabilidad en público. Según Check Point, el software afectado es el servidor web embebido RomPager de AllegroSoft. Escaneos a nivel de Internet sugieren que RomPager es probablemente el software de servidor web más popular del mundo en cuanto al número de endpoints disponibles. RomPager suele estar integrado en el firmware que se distribuye con el dispositivo. Esta vulnerabilidad específica se introdujo en la base de código en 2002. Además, los dispositivos expuestos son aquellos que utilizan servicios RomPager con versiones anteriores a la 4.34 (y específicamente la 4.07).
Para este tutorial usaré un ZXHN H108L que utiliza Rompager 4.07
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic realm="ZXHN H108L"
Content-Type: text/html
Transfer-Encoding: chunked
Server: RomPager/4.07 UPnP/1.0
EXT:
Ahora usemos el puerto serie; primero debemos determinar la velocidad de baudios
$ sudo stty -F /dev/ttyUSB0
SALIDA :
speed 115200 baud; line = 0;
-brkint -imaxbel
dispositivo
Yo uso minicom, puedes usar cualquier cosa desde screen hasta HyperTerminal, pero prefiero este por su estabilidad ;)
$ sudo minicom -s
+-----------------------------------------------------------------------+
| A - Dispositivo Serie : /dev/modem |
| B - Ubicación del archivo de bloqueo : /var/lock |
| C - Programa de llamada : |
| D - Programa de salida : |
| E - Bps/Par/Bits : 115200 8N1 |
| F - Control de flujo por hardware : No |
| G - Control de flujo por software : No |
| |
| ¿Cambiar qué ajuste? |
+-----------------------------------------------------------------------+
| Pantalla y teclado |
| Guardar configuración como dfl |
| Guardar configuración como.. |
| Salir |
| Salir de Minicom |
+--------------------------+
Ahora estamos listos:
$ sudo minicom -D /dev/ttyUSB0 -b 115200
Bootbase Version: VTC_SPI1.26 | 2012/12/26 16:00:00
RAM: Size = 8192 Kbytes
Encontrado SPI Flash 2MiB GD25Q16 en 0xbfc00000
SPI Flash Quad Enable
Desactivar modo Quad
RAS Version: ZXHN H108LV4.0.0a_ZRQ_MA
System ID: $2.12.162.0(G94.BY.2)3.20.19.0| 2014/03/21 20140321_v006 | 2014
Presiona cualquier tecla para entrar en modo debug en 3 segundos.
..........
Para mostrar los comandos posibles:
$ ATHE
======= Listado de Comandos Debug =======
AT solo responde OK
ATHE muestra ayuda
ATBAx cambia la velocidad de baudios. 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
ATENx,(y) establece el Flag de Debug de BootExtension (y=contraseña)
ATSE muestra la semilla del generador de contraseñas
ATTI(h,m,s) cambia la hora del sistema a hora:min:seg o muestra la hora actual
ATDA(y,m,d) cambia la fecha del sistema a año/mes/día o muestra la fecha actual
ATDS vuelca la pila RAS
ATDT vuelca el Área Común del Módulo de Arranque
ATDUx,y vuelca el contenido de memoria desde la dirección x con longitud y
ATRBx muestra el valor de 8 bits de la dirección x
ATRWx muestra el valor de 16 bits de la dirección x
ATRLx muestra el valor de 32 bits de la dirección x
ATGO(x) ejecuta el programa en la dirección x o inicia el router
ATGR inicia el router
ATGT ejecuta el Programa de Prueba de Hardware
ATRTw,x,y(,z) prueba de RAM nivel w, desde la dirección x hasta y (z iteraciones)
ATSH vuelca datos relacionados con el fabricante en ROM
ATDOx,y descarga desde la dirección x con longitud y al PC vía XMODEM
ATTD descarga la configuración del router al PC vía XMODEM
ATUR sube el firmware del router a la ROM flash
< presiona cualquier tecla para continuar >
Este firmware tiene un conjunto de comandos ocultos que son muy útiles para nuestro análisis dinámico. El problema es que no podemos ver los registros ni establecer puntos de interrupción, pero con suerte con estos comandos ocultos tendríamos esas características. Para verlos y usarlos necesitamos usar ATEN. Sin embargo, este comando requiere una contraseña, así que ¿qué podemos hacer ahora? Vamos a aplicar ingeniería inversa al firmware para encontrar el algoritmo del generador de contraseñas.
(Análisis estático) Veamos primero el archivo del firmware:
$ binwalk ras
binwalk1
$ dd if=ras of=rom1.lzma bs=1 skip=85043 count=66696
$ dd if=ras of=rom2.lzma bs=1 skip=350259 count=3350556
$ lzma -d <rom1.lzma> rom1
$ lzma -d <rom2.lzma> rom2
Veamos ahora la firma en los archivos extraídos:
$ binwalk -Y rom1
DECIMAL HEXADECIMAL DESCRIPTION
--------------------------------------------------------------------------------
0 0x0 código ejecutable MIPS, 32/64 bits, big endian, al menos 1250 instrucciones válidas
string es una gran herramienta para hacerse una idea de qué es un archivo binario o qué contiene. Veamos si podemos encontrar el algoritmo de la contraseña:
$ strings rom1 | grep -i aten
$ strings rom2 | grep -i aten
Aparentemente, no podemos verlo porque el firmware aún está comprimido, lo que significa que debemos volcarlo desde el router usando el modo de depuración:
$ ATDO bfc00000, 1f0000
xmodem
Lo primero que viene a la mente es comenzar a buscar una tabla de despacho. ¿Por qué? Solo intuición, la única alternativa es if-elif, pero sería un conjunto largo de ellos para verificar la validez de la contraseña proporcionada por el usuario, y esto es lo que obtuve:
ROM:800158A0 CmdTable: .word unk_80015C20 # DATA XREF: sub_8000E3D8+4Co
ROM:800158A0 # sub_8000E3D8+90o ...
ROM:800158A4 .word sub_8000E6D0
ROM:800158A8 .byte 0
ROM:800158A9 .byte 0
ROM:800158AA .byte 0
ROM:800158AB .byte 0
ROM:800158AC .word aJustAnswerOk # " just answer OK"
ROM:800158B0 .word aAthe # "ATHE"
ROM:800158B4 .word CMD_SHOW_HELP_ATHE
ROM:800158B8 .byte 0
ROM:800158B9 .byte 0
ROM:800158BA .byte 0
ROM:800158BB .byte 0
ROM:800158BC .word aPrintHelp # " print help"
ROM:800158C0 .word aAtba # "ATBA"
ROM:800158C4 .word CMD_ATBA
...
ROM:800158D0 .word aAten # "ATEN"
ROM:800158D4 .word CMD_ATEN
Ten en cuenta que la palabra MIPS es de 4 bytes, ahora veamos CMD_ATEN:
ROM:8000FF84 lw $a0, 8($s0)
ROM:8000FF88 jal sub_80013654
ROM:8000FF8C li $a1, 0
ROM:8000FF90 jal passwd_generator
y ahora: passwd_generator
ROM:80010A2C passwd_generator: # CODE XREF: CMD_ATEN+50p
ROM:80010A2C lui $t9, 0xA11F
ROM:80010A30 lw $v1, ptrDO_GTABLE
ROM:80010A34 lw $t8, dword_80017050
ROM:80010A38 lw $v1, 0x18($v1) # toma la parte de la semilla, generada por el comando ATSE
ROM:80010A3C lbu $t8, 0x6D($t8) # toma el último byte de la Dirección MAC
ROM:80010A40 sll $v1, 8 # $v1 = v1 << 8
ROM:80010A44 andi $t7, $t8, 7 # $t7 = t8 & 0x7
ROM:80010A48 li $t8, 0 # $t8 = 0
ROM:80010A4C srl $v1, 8 # $v1 = v1 >> 8
ROM:80010A50 li $t9, 0xA11F5AC6 # $t9 = MAGIC
ROM:80010A54 j loc_80010A68
ROM:80010A58 addu $t9, $v1, $t9 # $t9 = $v1 + $t9
ROM:80010A5C # ---------------------------------------------------------------------------
ROM:80010A5C
ROM:80010A5C loc_80010A5C: # CODE XREF: passwd_generator+40j
ROM:80010A5C sll $t9, 31 # $t9 = $t9 << 31
ROM:80010A60 or $t9, $t6, $t9 # $t9 = $t6 | $t9
ROM:80010A64 addiu $t8, 1 # $t8 = $t8 + 1
ROM:80010A68
ROM:80010A68 loc_80010A68: # CODE XREF: passwd_generator+28j
ROM:80010A68 sltu $t6, $t8, $t7 # $t6 = (t8 < t7? 1:0)
ROM:80010A6C bnez $t6, loc_80010A5C # salta si $t6 != 0
ROM:80010A70 srl $t6, $t9, 1 # $t6 = $t9 >> 1
ROM:80010A74 jr $ra # todo listo, salir
ROM:80010A78 xor $v0, $t9, $v1 # $v0 = $t9 ^ $v1
Lo que podemos concluir:
Ahora hagamos un programa en C que haga lo mismo y compilémoslo:
U32 passwd_generator(U32 seed, U8 last_mac_octet)
{
U32 b = seed & 0x00FFFFFF;
U32 r = ROR(b + 0xA11F5AC6, last_mac_octet & 7);
return r^b;
}
Ahora ejecutemos ATSE para obtener la semilla y usarla (por ejemplo: obtuve 088521A78838):
$ ./gen_pass 088521A78838
Ejecutemos el comando mágico que acabamos de hackear :p
$ ATEN1, A12F5AC6
ATEN1, A12F5AC6
OK
ATHE
======= Listado de Comandos Debug =======
AT solo responde OK
ATHE muestra ayuda
ATBAx cambia la velocidad de baudios. 1:38.4k, 2:19.2k, 3:9.6k 4:57.6k 5:115.2k
ATENx,(y) establece el Flag de Debug de BootExtension (y=contraseña)
ATSE muestra la semilla del generador de contraseñas
ATTI(h,m,s) cambia la hora del sistema a hora:min:seg o muestra la hora actual
ATDA(y,m,d) cambia la fecha del sistema a año/mes/día o muestra la fecha actual
ATDS vuelca la pila RAS
ATDT vuelca el Área Común del Módulo de Arranque
ATDUx,y vuelca el contenido de memoria desde la dirección x con longitud y
ATWBx,y escribe en la dirección x el valor de 8 bits y
ATWWx,y escribe en la dirección x el valor de 16 bits y
ATWLx,y escribe en la dirección x el valor de 32 bits y
ATRBx muestra el valor de 8 bits de la dirección x
ATRWx muestra el valor de 16 bits de la dirección x
ATRLx muestra el valor de 32 bits de la dirección x
ATGO(x) ejecuta el programa en la dirección x o inicia el router
ATGR inicia el router
ATGT ejecuta el Programa de Prueba de Hardware
AT%Tx Habilita el Programa de Prueba de Hardware al arrancar
ATBTx habilitar escritura en bloque0 (1=habilitar, otro=deshabilitar)
< presiona cualquier tecla para continuar >
ATRTw,x,y(,z) prueba de RAM nivel w, desde la dirección x hasta y (z iteraciones)
ATWEa(,b,c,d) escribe dirección MAC, código de país, EngDbgFlag, FeatureBit en la ROM flash
ATCUx escribe código de país en la ROM flash
ATCB copia desde la ROM flash al buffer de trabajo
ATCL limpia el buffer de trabajo
ATSB guarda el buffer de trabajo en la ROM flash
ATBU vuelca datos relacionados con el fabricante en el buffer de trabajo
ATSH vuelca datos relacionados con el fabricante en ROM
ATWMx establece los 6 dígitos bajos de la dirección MAC en el buffer de trabajo
ATMHx establece los 6 dígitos altos de la dirección MAC en el buffer de trabajo
ATBS muestra la semilla del bootbase del generador de contraseñas
ATLBx subida xmodem del bootbase, x es la contraseña
ATSMx establece los 6 dígitos de la dirección MAC en el buffer de trabajo
ATCOx establece el código de país en el buffer de trabajo
ATFLx establece EngDebugFlag en el buffer de trabajo
ATSTx establece la dirección ROMRAS en el buffer de trabajo
ATSYx establece el tipo de sistema en el buffer de trabajo
ATVDx establece el nombre del vendedor en el buffer de trabajo
ATPNx establece el nombre del producto en el buffer de trabajo
ATFEx,y,... establece los bits de característica en el buffer de trabajo
ATMP verifica y vuelca memMapTab
ATDOx,y descarga desde la dirección x con longitud y al PC vía XMODEM
< presiona cualquier tecla para continuar >
ATTD descarga la configuración del router al PC vía XMODEM
ATUPx,y sube a la dirección RAM x con longitud y desde el PC vía XMODEM
ATUR sube el firmware del router a la ROM flash
ATDC deshabilita la verificación de la versión del hardware durante la subida del firmware
ATLC sube el archivo de configuración del router a la ROM flash
ATUXx(,y) subida xmodem desde el bloque flash x hasta y
ATERx,y borra la ROM flash desde el bloque x hasta y
ATWFx,y,z copia datos desde la dirección x a la dirección flash y, longitud z
ATXSx selección xmodem: x=0: modo CRC (por defecto); x=1: modo checksum
ATLD Sube el archivo de configuración y el archivo ROM por defecto a Flash
ATBR Reinicia al Romfile por defecto
ATCD Convierte el archivo ROM en ejecución en archivo ROM por defecto en Flash
OK
Finalmente, obtenemos un conjunto completamente nuevo de comandos que nos permite volcar la memoria
$ ATMP
ROMIO image start at bfc30000 code version: code start: 80008000 code length: 1A5D4E memMapTab: 18 entradas, start = bfc44000, checksum = 9770 $Sección RAM: 0: BootExt(RAMBOOT), start=80030000, len=18000 1: HTPCode(RAMCODE), start=80048000, len=E0000 2: RasCode(RAMCODE), start=80048000, len=420000 $Sección ROM: 3: BootBas(ROMIMG), start=bfc28000, len=4000 4: DbgArea(ROMIMG), start=bfc2c000, len=2000 5: RomDir2(ROMDIR), start=bfc2e000, len=2000 6: BootExt(ROMIMG), start=bfc30030, len=13FD0 7: MemMapT(ROMMAP), start=bfc44000, len=C00 8: HTPCode(ROMBIN), start=bfc44c00, len=8000 (Comprimido) Versión: HTP_TC V 0.05, start: bfc44c30 Longitud: 10488, Checksum: CB32 Longitud comprimida: 41CF, Checksum: D5A5 9: termcap(ROMIMG), start=bfc4cc00, len=400 10: RomDefa(ROMIMG), start=bfc4d000, len=2000 11: LedDefi(ROMIMG), start=bfc4f000, len=400 12: LogoImg(ROMIMG), start=bfc4f400, len=2000 13: LogoImg2(ROMIMG), start=bfc51400, len=2000 14: StrImag(ROMIMG), start=bfc53400, len=32000 15: StrImag2(ROMIMG), start=bfc85400, len=32000 16: Rt11nE2p(ROMIMG), start=bfcb7400, len=400 17: RasCode(ROMBIN), start=bfcb7800, len=246C00 (Comprimido) Versión: ADSL ATU-R, start: bfcb7830 Longitud: 321D2C, Checksum: 582D Longitud comprimida: 11E54B, Checksum: B30B $Sección USUARIO: Msecs 128 Heap0 16 300 16 Heap1 32 64 4 Heap2 64 64 4 Heap3 128 160 4 Heap4 192 256 4 Heap5 256 80 4 Heap6 320 20 4 Heap7 384 4 2 Heap8 448 20 2 Heap9 512 34 2 Heap10 1024 52 4 Heap11 2048 20 2 Heap12 3172 4 2 Heap13 4096 2 2 Heap14 0 0 ...
Lo que acabamos de aprender nos ayudará a analizar los archivos rom que extrajimos anteriormente
code start: 80008000 code length: 1A5D4E
Ahora podemos establecer la __Dirección de inicio de ROM__ y la __Dirección de carga__ en __0x80008000__ después de volcar un nuevo archivo rom usando:
$ ATDO 80008000, 1A5D4E
Sabemos que __ATGR__ inicia el router, así que lo que podríamos hacer es rastrearlo para encontrar las instrucciones que pasan la ejecución a la segunda parte del firmware.
atgr1
```assembly
ROM:80011E8C loc_80011E8C: # CODE XREF: LoadAndRunImage+D8j
ROM:80011E8C jal sub_80009B24
ROM:80011E90 li $a0, 0x1F4
ROM:80011E94
ROM:80011E94 execute_image: # ejecutar imagen
ROM:80011E94 jalr $s0 # salta y enlaza a la dirección en $s0
ROM:80011E98 nop
Ahora necesitamos preguntar ¿cuál es la dirección almacenada en $s0? Obviamente, todavía no podemos establecer un punto de interrupción, no podemos ver los registros, así que necesitamos filtrarlo usando algún truco. Afortunadamente, podemos leer y escribir memoria, echa un vistazo al siguiente comando:
ATWL 80011E94, ae30001c
ATGR
Por lo que parece, este comando parchea la instrucción en 0x80011E94 con ae30001c (la representación en bytes de la instrucción MIPS sw $s0, 0x1C($s1)). Al sobrescribir el jalr $s0 original con sw $s0, 0x1C($s1) hemos forzado al programa a almacenar el contenido del registro $s0 en la dirección de memoria 0x8001FF1C. Así que ahora el firmware de la segunda etapa no se ejecutará, en su lugar se presentará el mensaje "ERROR" y aún tendremos acceso a la consola de la primera etapa. ¡Hurra! Así que echemos un vistazo a lo que se almacenó en 0x8001FF1C.
ATRL 8001FF1C
8001FF1C: 80020000
¡Lo tengo! ... usando 0x80020000 podemos volcar y analizar correctamente la segunda parte del firmware.
Continuará...