Esta es la segunda parte de mi tutorial. Imagino que si estás leyendo esto ya habrás leído y entendido la guía conceptual de exploits.
¿Por qué otra guia para encontrar exploits, habiendo tantas en páginas similares? Principalmente creo que los otros tutoriales que he leído no están preparados para que cualquier usuario, al leerlos, pueda entender totalmente el contenido sin conocimientos previos sobre el tema. La finalidad de mi primera guía es dar las definiciones generales para poder comenzar con la busqueda de exploits sabiendo como actuar y que se está haciendo realmente.
Una vez comprendidos los conceptos, uno ya puede comenzar la busqueda de una vulnerabilidad, pero ¿cómo hago eso?. Justamente a eso apunta esta segunda parte de mi tutorial. La guía esta enfocada unicamente en la busqueda de exploits a traves del emulador JPCSP, pero bien podría servir también para buscar exploits en una PSP ya que lo que se hace en definitiva es lo mismo.
Lo primero que se necesita es descargar algunas herramientas para poder seguir la guía:
Contenido
- Configurando JPCSP
- Desbordar Buffer y tomar control sobre $ra
- Creando Cargador Binario y Hola Mundo
- Inyectando Cargador Binario
- Redireccionando $ra a nuestro Cargador
1. Configurando JPCSP
Los cambios en la configuración del emulador son pocos, le vamos a indicar que no ignore las direcciones de memoria no validas (esto permite que crashee) y que guarde las partidas en archivos desencriptados.
Ir a Options > Configuration para abrir el menú de configuración.
En Memory, deshabilitar (si es necesario) la opción Ignore invalid memory access:
En Crypto, deshabilitar Handle SAVEDATA in crypto mode y habilitar Extract decrypted EBOOT.BIN files to the TMP folder, opción que será necesaria luego para crear el cargador binario:
2. Desbordar el buffer y tomar control sobre $ra
El paso siguiente es lograr que una cadena de texto conocida aparezca en el archivo guardado, por ejemplo, crear un nuevo perfil en el juego o registrar un highscore. Si el juego ya tiene nombres de jugadores en un highscore por defecto lo más probable es que esos nombres ya aparezcan en la partida guardada; para verificar abrir el archivo con XVI32 y revisar si se encuentra alguno de estos nombres dentro. En caso contrario, que la lista esté vacía, no tenemos más que registrar un puntaje y ponerle de nombre un texto que luego identificaremos.
Se mostrará el procedimiento a seguir con uno de los juegos que estoy usando para explotar. Creé un perfil con el nombre GUIDO. Esta cadena es facil de encontrar, si bien hay muchas apariciones me voy a quedar con la primera por un tema de comodidad.
NOTA: Cualquier otra aparición podría servir para explotar el buffer, no tiene porque ser solo la primera.
Ahora si lo que buscamos es desbordar el buffer, tendremos que alargar esa cadena agregando caracteres:
Voy a agregar el caracter A, cuyo número en hexadecimal es 0×41 unas 200 veces:
NOTA: El largo de la cadena puede variar según que juego se esté tratando de explotar, algunos necesitan más caracteres para poder desbordar el buffer y otros menos.
Una vez agregada la cadena de A’s el archivo debería verse como el siguiente:
Ya tenemos una cadena bastante larga que podría desbordar el buffer!
No queda más que probarlo con JPCSP para ver que sucede. Para que un exploit se active a veces es necesario entrar al menú exacto donde se carga esa cadena. Por ejemplo puede que al cargar el perfil el juego no crashee, pero si lo haga al tratar de cambiar el nombre del mismo.
El juego, al cargar la partida, podría bien tirar un error de datos corruptos o algo por el estilo. Si este es el caso, lamentablemente el juego no va a poder ser explotado.
Una vez encontrada alguna opción que haga crashear el emulador, la ventana de consola de JPCSP debería mostrar un error de este tipo:
Esta ventana es buena, es la que buscamos, la mayoría de las veces sale cuando la dirección de $ra es inválida (fue sobreescrita)
¿Eso significa que tenemos control sobre $ra?
La única forma de saberlo es mirando el debugger. Para abrirlo ir a Debug > Tools > Debugger
Si tuvimos suerte, nuestra cadena desbordó el programa y sobreescribió al registro $ra (y seguramente a más de un registro $sx)
¡Bien! Ya sabemos que nuestra super cadena de A’s sobreescribe el registro de $ra en la memoria.
¿Qué hace falta?
Como el objetivo de sobreescribir el registro $ra es poder saltar a otra dirección de memoria, poco nos sirve que apunte a la dirección 0×41414141 que ni siquiera existe. Para poder controlar con total libertad este valor deberíamos averiguar cuales son los cuatro caracteres de la cadena que pisan $ra.
Mi método consiste en poner distintos caracteres dentro de la partida guardada, reemplazando las A’s de la siguiente manera:
Esto debería darnos una mejor idea del rango donde están los 4 bytes que sobreescriben el registro a la hora de cargar la cadena, procedemos a crashear nuevamente el juego y ver que ocurre con $ra ahora:
¡Conseguimos lo que buscabamos!
$ra ahora vale 0×45454343 (equivalente a EECC), esto significa que los dos últimos bytes de la cadena de C’s y los dos primeros de la cadena de E’s son los que sobreescriben el registro $ra:
NOTA: En algunos exploits no es tan sencillo ubicar la posición de $ra, podría estar a mitad de la cadena de F’s. En ese caso deberíamos reemplazar la cadena de F’s por otra; por ejemplo por el abecedario. Luego ver que valor toma $ra y con eso deberíamos poder sacar la ubicación exacta en el archivo.
¡Felicidades, ya tienes control sobre $ra!
3. Creando Cargador Binario y Hola Mundo
¿Qué es el cargador binario?
El cargador binario es un simple código compilado que llama a la función sceIoOpen, sceIoRead, sceIoClose y sceIoWriteBack(varía) para cargar un archivo H.BIN que se encargará de seguir la ejecución del exploit.
Hablando mal y pronto, el cargador binario se carga con la partida guardada y hace que la ejecución de código siga en otro archivo (H.BIN).
Para poder compilar un cargador binario es necesario realizar algunos cambios en la partida guardada:
Primero, dejando bastantes lineas para insertar nuestro cargador luego, escribimos la ruta al archivo H.BIN que pondremos junto al savedata:
El marcado en rojo es el espacio reservado para luego insertar el cargador binario allí.
NOTA: La ruta debe terminar con un caracter nullo (0×00).
Muy importante
Para poder compilar el cargador binario es necesario obtener el siguiente valor: La diferencia en hexadecimal del inicio de la ruta y el inicio del cargador binario.
En este ejemplo este valor es 0×118 – 0x8C = 0x8C
Recordar que es una operación en hexadecimal. No intentar hacer la resta como si fueran números en decimal porque daría un valor incorrecto.
En esta parte haremos uso de la herramienta ExploitTools previamente descargada.
Dentro de la carpeta de JPCSP/tmp debería haber una carpeta con nombre del código del juego, dentro de esa carpeta hay un archivo EBOOT.BIN (tmp/NPUZXXXXXX/EBOOT.BIN)
Copiar el archivo EBOOT.BIN en ExploitTools/SDKCreator/
Ejecutar el archivo START.BAT
Si todo sale bien, la consola debería mostrar el mensaje:
Done! Remember to modify XX in loader.s file!
Recuerda modificar el XX en el archivo loader.s
Luego de esto, se crearán dos archivo en la misma carpeta: loader.s y sdk.S
Si no hubiera incluído el programa SDKCreator, uno debería usar la salida que imprime prxtool, a cada valor de cada función sumarle 0×08804000 y hacer los archivos sdk.S y loader.s manualmente, reemplazando la dirección de cada funcion por la correspondiente.
Abrir el archivo loader.s con cualquier editor de texto y reemplazar el valor indicado por el valor que obtuvimos antes resultante de la resta de direcciones (La diferencia entre el comienzo del path y el comienzo de cargador binario).
Realizada esta pequeña modificación, copiar el archivo loader.s en ExploitTools/BinaryLoader y copiar el archivo sdk.S en ExploitTools/HelloWorld
Hora de compilar el archivo H.BIN (Hola mundo). Para ello dirijirse a ExploitTools/HelloWorld y abrir el archivo COMPILAR.BAT, esto generará un archivo H.BIN. Copiar este archivo en la carpeta de juego explotado.
Ahora solo queda compilar el cargador binario, ir a la carpeta ExploitTools/BinaryLoader y abrir el archivo COMPILAR.BAT; si todo sale bien aparecerá un archivo a.bin.
4. Inyectando Cargador Binario
Esta parte es muy sencilla, no es más que reemplazar los bytes del archivo guardado con los bytes del archivo a.bin.
Abrir el archivo a.bin con XVI32.
Ubicarse en el primer byte, mantener presionado Shift y moverse con las flechas hacia abajo y a la derecha hasta tener todos los bytes marcados en rojo.
Ir a Edit > Clipboard > Copy as hex string
Cerrar el archivo a.bin y abrir nuevamente el archivo de la partida guardada.
Dirijirse al area que previamente habiamos reservado para el cargador binario (Dirección 0x8C)
Ubicado en el primer byte del espacio reservado, ir a Edit > Overwrite string.
En la ventana seleccionar la opción Hex string y pegar en el cuadro de texto el código del cargador binario previamente copiado con CTRL+V y presionar OK.
Todo listo, el archivo guardado ahora debería lucir así (no exactamente igual):
Sabiendo que el area remarcada en violeta es el area que habiamos definido previamente para insertar el cargador.
¡El cargador ya está dentro del archivo!
5. Redireccionando $ra a nuestro Cargador
Ya tenemos nuestro cargador binario en memoria, ahora necesitamos que el código haga un salto a la dirección donde está ubicado.
Para ello necesitariamos saber precisamente en que dirección de la memoria RAM de la psp se almacena el cargador.
Volviendo a JPCSP, una vez que el juego crashea, haremos un dumpeo de la memoria usando la función en Debug > Tools > Memory Viewer > Dump raw RAM memory
Esto genera un archivo ramdump.bin de unos 32MB en la carpeta de JPCSP. Abrir el archivo con XVI32.
Lo que buscamos en este archivo es donde está guardada nuestra super cadena con el cargador binario, podemos usar la función find con CTRL+F y tratar de buscar, por ejemplo, la cadena CCCCEEEEEEEEEEEE.
Sabemos bien que nuestro cargador binario comienza justo despues de la última letra E, esa es la dirección que buscamos. En este caso nuestra dirección sería 0x9B3C8C.
Como las direcciones de memoria en PSP comienzan en 0×08000000 y nuestra dirección en el dump está tomada desde el número cero, la dirección final de memoria donde se encuentra el cargador binario es 0×08000000 + 0x9B3C8C = 0x089B3C8C
¡Ahora solo falta redireccionar $ra a esa dirección!
Abrimos nuevamente nuestra partida guardada; ya sabemos que los 4 bytes que reemplazan a $ra son las dos últimas C y las dos primeras E
Ahora simplemente reemplazamos, desde el lado izquierdo de XVI32, los valores en hexadecimal de nuestra dirección final invertida:
Si todo salió bien, la proxima vez que el juego crashee debería cargar el hola mundo
