viernes, 7 de febrero de 2014

Vulnerabilidad en el iBoot de iPhone 4S

Hace unos pocos días pudimos ver en Twitter como un conocido Jailbreaker, iH8sn0w, comentaba haber encontrado una vulnerabilidad en los dispositivos con procesador A5 de Apple (iPhone 4S, por ejemplo). 



Según sus propias palabras, la vulnerabilidad se encontraría en el iBoot, una de las partes del arranque de los dispositivos de Apple que se ejecuta previamente a la ejecución del kernel del sistema operativo iOS. 


El arranque de un dispositivo iOS se realiza mediante la llamada "Secure Boot Chain", en la que cada etapa realiza sus acciones pertinentes y comprueba la firma de la siguiente etapa antes de otorgarle el control. 

La primera etapa de todas, el bootrom, se escribe en el dispositivo en el momento del ensamblaje, y no puede ser cambiada ni actualizada en toda la vida del mismo. Las vulnerabilidades en alguno de estos elementos del arranque, o en el propio kernel, permitirían evadir esta protección de la firma, y por lo tanto arrancar versiones modificadas del kernel, que es en lo que consiste un Jailbreak. 

No obstante, a pesar de que el propio iH8sn0w comenta que, a partir de ahora, los dispositivos A5 son "Jailbreakeables" de por vida, a priori únicamente las vulnerabilidades en el bootrom serían de este tipo, ya que al estar embebido en el propio hardware es el único elemento que no puede ser actualizado por Apple. El iBoot, elemento en el que parece existir la vulnerabilidad, se encuentra dentro de la imagen del sistema operativo iOS que descargamos en el momento de realizar una actualización, dentro del fichero IPSW, por lo que Apple podría corregir la vulnerabilidad en próximas releases. 

Dado que los detalles de la vulnerabilidad aún no han sido publicados y todavía no podemos ponernos a jugar con ella, vamos a descargar el IPSW de una versión vulnerable y a intentar extraer la imagen del iBoot. Para ello lo primero que vamos a hacer es descargar la imagen con la que vamos a trabajar, por ejemplo la versión 7.0.4 para iPhone 4S, de la conocida web ipswdownloader.com.


El fichero IPSW no es más que un ZIP al que se le ha cambiado la extensión, pero sus ficheros se encuentran cifrados mediante el algoritmo AES, empleando claves a priori desconocidas. Veamoslo: 

$ file iPhone4,1_7.0.4_11B554a_Restore.ipsw 
iPhone4,1_7.0.4_11B554a_Restore.ipsw: Zip archive data, at least v2.0 to extract 

$ unzip iPhone4,1_7.0.4_11B554a_Restore.ipsw 
Archive: iPhone4,1_7.0.4_11B554a_Restore.ipsw 
inflating: 058-1077-002.dmg 
inflating: 058-1108-002.dmg 
inflating: 058-1124-002.dmg 
inflating: BuildManifest.plist 
creating: Firmware/ 
creating: Firmware/all_flash/ 
creating: Firmware/all_flash/all_flash.n94ap.production/ 
inflating: Firmware/all_flash/all_flash.n94ap.production/applelogo@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/batterycharging0@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/batterycharging1@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/batteryfull@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/batterylow0@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/batterylow1@2x~iphone.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/DeviceTree.n94ap.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/glyphplugin@2x~iphone-30pin.s5l8940x.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/iBoot.n94ap.RELEASE.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/LLB.n94ap.RELEASE.img3 
inflating: Firmware/all_flash/all_flash.n94ap.production/manifest 
inflating: Firmware/all_flash/all_flash.n94ap.production/recoverymode@2x~iphone-30pin.s5l8940x.img3 
creating: Firmware/dfu/ 
inflating: Firmware/dfu/iBEC.n94ap.RELEASE.dfu 
inflating: Firmware/dfu/iBSS.n94ap.RELEASE.dfu 
inflating: Firmware/Trek-5.0.02.Release.bbfw 
inflating: Firmware/Trek-5.0.02.Release.plist 
creating: Firmware/usr/ 
creating: Firmware/usr/local/ 
creating: Firmware/usr/local/standalone/ 
inflating: kernelcache.release.n94 
inflating: Restore.plist 

$ srch_strings Firmware/dfu/iBSS.n94ap.RELEASE.dfu | head -10 
3gmI 
ssbiEPYT 
ssbi 
ATAD 
jnZf 
UZ^_ 
[...] 

Como podemos ver, el formato de los ficheros no es reconocido, debido a que su contenido está cifrado. A pesar de que la clave de cifrado no se publica por Apple, los Jailbreakers las obtienen como parte de su trabajo de investigación, y van publicando aquellas que identifican, por ejemplo, en el iPhoneWiki

En este caso, el propio iH8sn0w ha colgado en su Twitter una de las claves que ha encontrado durante su trabajo: 


Con esta información ya podemos extraer las imágenes del IPSW que acabamos de descargar. Imagino que podríamos hacerlo a mano con openssl, pero yo he preferido usar una versión modificada del script "kernel_patcher.py" de la suite iphone-dataprotection (que podéis descargar de AQUI). 

Básicamente, en script es el mismo que el original pero eliminando las acciones de parcheo del kernel, dejando las imágenes tal cual se encuentran dentro del IPSW. Veamos si funciona: 

$ ./ipsw_decrypt.py --iv 3a0fc879691a5a359973792bcd367277 --key 371e3aea9121d90b8106228bf2b5ee4c638a0b4837fefbd87a3c0aca646e5996 --binary iBSS iPhone4,1_7.0.4_11B554a_Restore.ipsw 
Decrypting iBSS.n94ap.RELEASE.dfu 
Decrypted kernel written to iBSS.n94ap.RELEASE.dfu.decrypt 

Parece que todo ha funcionado bien, así que solo nos queda ver si efectivamente lo que hay dentro tiene pinta de iBSS: 

$ srch_strings iBSS.n94ap.RELEASE.dfu.decrypt 
iBSS for n94ap, Copyright 2013, Apple Inc. 
RELEASE 
iBoot-1940.3.5 
[...] 

Pues... todo apunta a que sí. Lamentablemente cada imagen está cifrada con una clave diferente y no podemos utilizar esta misma clave para descifrar el iBoot y ponernos a mirar, así que por el momento habrá que esperar a ver si son publicados más detalles sobre la vulnerabilidad.

miércoles, 13 de noviembre de 2013

NcN PreQuals 2013: Reto 3 (b)

Hace unos días, tras la solución del Reto 1 y el Reto 2 de las quals del CTF de la NcN de este año, os comentaba una posible solución al Reto 3, y os dejaba pendiente una segunda solución "tirando de debugger", que  es la que veremos hoy.

Yo voy a utilizar radare2 para hacerlo, pero podríais utilizar gdb, IDA, o vuestro debugger favorito.
Para los que se pierdan como yo mirando el puro ensamblador, radare2 tiene una función con la que podemos pintar un poco los bloques de las funciones, lo cual nos ayudará a visualizar un poco mejor lo que pasa:

$ r2 -d level.elf
[0x0040101f]> af@main
[0x0040101f]> ag > foo.dot
foo.dot created

Hemos abierto el binario y nos hemos colocado en el main, y desde ahí generamos la gráfica que comentábamos anteriormente. Ahora solo tenemos que convertirla a otro formato más visible, por ejemplo PNG:

 $ dot -Tpng foo.dot > foo.png


No voy a subir el PNG a alta resolución (podéis generarlo vosotros mismos), pero creo que con esta captura será suficiente para que veáis el proceso.

¿Os acordáis que nos habíamos dado cuenta que la aplicación comparaba carácter a carácter? Quizá buscar bucles sea un buen punto de partida. En este caso, se puede ver fácilmente en la gráfica que existen únicamente DOS bucles (los identificamos porque hay flechas que vuelven a bloques anteriores). Si miramos ambos detenidamente veremos que el que nos interesa es el de la izquierda de los que tenéis marcados. Las dos flechas señalan donde están los dos puntos donde voy a hacer zoom a continuación, para que no os perdáis.

Pegando un vistazo al bucle, observamos una bifurcación curiosa:


Como podéis ver, llega un momento en el que se realiza una comparación y el flujo de la ejecución se va a una rama que llama a la función game_over(), o a otra rama que llama a las funciones success() y después a no_me_jodas_manolo() (vaya nombre xDDD). Está claro que lo que nos interesa es forzar a que la ejecución del programa vaya a esta última rama, pero nos interesa hacerlo desde algún sitio en el que el contenido cifrado ya haya sido descifrado, o sino seguramente no vamos a conseguir nada ¿Donde podemos estar seguros que estará el contenido cifrado pero todavía no hemos tenido que introducir caracteres? Pues al comienzo del bucle que estábamos mirando.


Donde tenéis la fecha roja es el bloque a donde vuelve el bucle, con lo que... ¿qué pasará si sobre escribimos el contenido y metemos un salto al bloque que nos da la solución? ¿funcionará?

Os he marcado también con un recuadro rojo la que supuestamente es la comparación entre lo que introduce el usuario por teclado y lo que hay en memoria. Poniendo un breakpoint aquí y yendo a la zona de memoria a la que referencia seguramente también seríamos capaces de obtener la clave, pero de momento nosotros vamos a intentar hacer el bypass directo que comentábamos antes, a ver si funciona.

$ cp level.elf foolevel.elf
$ r2 -w foolevel.elf
[0x00400690]> s 0x0040114e
[0x0040114e]> wa jmp dword 0x0040117b
Written 5 bytes ( jmp dword 0x0040117b)=wx e928000000
[0x0040114e]> pd
      ,=< 0x0040114e     e928000000       jmp dword 0x40117b

Hemos abierto una copia de level.elf a la que hemos llamado foolevel.elf y la hemos abierto en modo de escritura. Nos hemos ido a la posición 0x0040114e, que es la del inicio del bucle, y hemos sobre escrito un salto a la posición 0x0040117b, que es la del bloque que suponemos que nos mostrará el flag. Ahora solo nos queda salir de radare y ejecutar el binario a ver que pasa:

$ ./foolevel.elf
|  >  Type to win, only what I want to read...
|  >  |
|  -> Congratulations! The key is:
|  9e0d399e83e7c50c615361506a294eca22dc49bfddd90eb7a831e90e9e1bf2fb

Bingo! Ya tenemos el flag de nuevo, pero esta vez no hemos necesitado sacar la clave. En otras situaciones no habríamos podido hacer esto (o hubiera resultado mucho más complicado), porque depende mucho de como esté implementado, pero en esta ocasión ha funcionado a las mil maravillas. Por supuesto, existen bastantes maneras de solucionar este mismo reto. Si lo habéis probado de otra manera y queréis dejar un comentario... será bien recibido :)

lunes, 11 de noviembre de 2013

NcN PreQuals 2013: Reto 3 (a)

En el último par de días habíamos hablado de la solución al Reto 1 y Reto 2 de las Quals del CTF de la NcN 2013, así que hoy nos toca ver la solución al Reto 3, el último en el que consistian las Quals. El reto consistía en un binario del que a priori no se proporcionaba más información.

En estos casos, lo mejor es empezar y saber ante que tipo de binario nos encontramos. Si no tiene la cabecera corrupta ni nada similar, debería bastarnos con usar el comando "file":

$ file level.elf 
level.elf: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0xb589d432799bf15343387fea63d4bdc00faa177c, not stripped

Ya sabemos algo sobre el binario, es un ELF de 64 bits, así que deberíamos buscarnos un Linux de 64 bits en el que correr este binario ¿No tienes ninguno a mano? En ese caso te pasó igual que a mi al resolver este reto :) Por suerte Linux 64 bits es algo que podemos descargar facilmente de Internet.

Una vez que ya tenemos un Linux de 64 bits y podemos ejecutar el binario, a mi siempre me gusta ejecutarlo una vez a ver lo que hace antes de meterte "a saco" a desensamblar. El funcionamiento del binario te puede dar pistas sobre lo que tienes que buscar en el código.

$ ./level.elf
|  >  Type to win, only what I want to read...
|  > f
|
|  -> I DON'T THINK SO

Cuando llamas al binario, se queda esperando a que pulses alguna tecla y, si es incorrecta, inmediatamente cierra la ejecución. Es de suponer que al introducir la clave correcta nos dará el deseado flag.

Antes de seguir, solo por si fuera así de sencillo, deberíamos hacerle un "strings" al binario, no sea que la contraseña aparezca directamente:

$ strings level.elf
/lib64/ld-linux-x86-64.so.2
libc.so.6
fflush
puts
putchar
[..]
795ef9462825a6640f9a9d7e85a01f5bb311c5849f8fc0e41bf4030f43e583f3
50a89ea2b500750f9baa163adee2057881b418e47bce9ddced4941556614e499
be0978a13b5875b112bcc84b4b688d68ec2d11010543189540bffa3641f2623d
911106de1b05db8d1b0fb2fe118345b4db6ddb930cf61290fd0b8336ffb394fd
a750b2d4129207fbbe6527ddd396f24327f4302c0b8496e154f139612bfc3312
a3f0e19a20d10cb055fbaaf4bbe82859074e50f4f8c2cde2b907c0947941ec98
[...]

No os pongo toda la salida, por no hacer grande el post, pero no vemos nada que pueda parecer la clave ni el flag, pero sí que vemos algo que tiene pinta de estar cifrado. Es muy común en este tipo de retos que haya información cifrada que el propio binario se encargue descifrar, para evitar que sea tan fácil sacar la clave.

Esta vez no hubo suerte con el strings, así que vamos a tener que ejecutar el binario para que haga su trabajo. Otra de las cosas que suelo hacer es usar el comando "ltrace" (o "strace", o "ptrace", según la ocasión). El comando "ltrace" nos mostrará las llamadas a librerías, con lo que si se ejecuta un strcmp() o similar debería aparecernos:

$ ltrace ./level.elf 
__libc_start_main(0x40101f, 1, 0x7fff991818e8, 0x4011c0, 0x401250
fputc('\n', 0x7f279f827260
)                                                                      = 10
fwrite("|  >  ", 1, 6, 0x7f279f827260)                                                           = 6
fflush(0|  >  )                                                                                        = 0
fwrite("Type to win, only what I want to"..., 1, 41, 0x7f279f827260)                             = 41
fflush(0Type to win, only what I want to read... )                                                                                        = 0
fputc('\n', 0x7f279f827260
)                                                                      = 10
fwrite("|  >  ", 1, 6, 0x7f279f827260)                                                           = 6
fflush(0|  >  )                                                                                        = 0
tcgetattr(0, 0x00603400)                                                                         = 0
tcsetattr(0, 0, 0x00603440)                                                                      = 0
getchar(0, 21505, 51729, -1, 0x603440)                                                           = 120
tcsetattr(0, 0, 0x00603400)                                                                      = 0
fputc('\n', 0x7f279f827260
[...]

Tampoco aparece nada, así que una de dos, o el programador está comparando carácter a carácter (algo coherente con el funcionamiento que hemos visto antes) o se ha implementado su propia versión de comparador de cadenas. Vamos a suponer lo primero y vamos a hacer una pequeña prueba: Vamos a hacer un pequeño script en python que pruebe todos los posibles valores ascii para el primer elemento, y vamos a pegar un vistazo a ojo a ver si hay algún cambio en la salida:

$ cat test.py 
#!/usr/bin/python
import os
for c in xrange(1,255):
cmd = 'echo '+str(c)+' ; echo "'+str(chr(c))+'" | ./level.elf'
os.system(cmd)

$ python test.py
[...]
31
|  >  Type to win, only what I want to read... 
|  >  
|
|  -> I DON'T THINK SO
32
|  >  Type to win, only what I want to read... 
|  >  *
|
|  -> I DON'T THINK SO
[...]

Vaya! Parece que sí que hay algo que cambia! Cuando probamos con el carácter 32 (0x20, vamos, el espacio) la salida nos marca con un asterisco, como señalando que hemos marcado un carácter bien, aunque nos sigue diciendo "I DON'T THINK SO", que nos hace ver que aún nos quedan caracteres por meter. Asumiendo que cada vez que acertemos otro carácter tendremos un asterisco más, y que esa frase de "I DON'T THINK SO" desaparecerá una vez obtengamos la solución, nos hacemos otro script en python para que nos automatice un poco la tarea:

$ cat bruteforce.py
#!/usr/bin/python
import subprocess
password = ""
for l in xrange(1,20):
        for c in xrange(1,255):
                if c == 34:
                        continue
                temp_pass = password + chr(c)
                result = subprocess.check_output('echo \"'+temp_pass+'\" | ./level.elf', shell=True)
                if "I DON'T THINK SO" not in result:
                        print temp_pass
                        print result
                        exit(0)
                n = result.count('*')
                if n == l:
                        print temp_pass
                        password = password + chr(c)
                        break

Hacemos un bucle de longitudes de 1 a 20 (podríamos poner más), y para cada posición probamos todos los posibles valores ascii y analizamos el resultado. Si la cantidad de caracteres asterisco es igual a la longitud de la clave que habíamos probado, es que es que hemos acertado, y sino tenemos que probar con el siguiente. Además, si la frase "I DON'T THINK SO" desaparece del resultado, probablemente hemos encontrado la contraseña correcta y tendremos la solución. Vamos a ver si funciona:

$ time ./bruteforce.py
 S
 SU
 SUR
 SURP
 SURPR
 SURPRI
 SURPRIS
 SURPRISE
 SURPRISE!
|  >  Type to win, only what I want to read...
|  >  **********
|
|  -> Congratulations! The key is:
|  9e0d399e83e7c50c615361506a294eca22dc49bfddd90eb7a831e90e9e1bf2fb

real    0m7.179s
user    0m0.772s
sys     0m4.316s

Bingo! Parece que ya tenemos el tercer flag :)
Este reto había muchas maneras de resolverlo. En este caso, como no soy persona que se dedique a hacer reversing a diario, me resultaba más cómoda esta aproximación, pero quise probar también a ver como lo podría haber resuelto arrancando el debugger y viéndole las tripas al binario, por eso he llamado a este post "a", porque falta la solución "b", con debugger.