Ultima versión (15/11/2010) :PsGrooPIC_C0C1-wBTL-Hermesv4b-PSN-350SPFSources (TSC)
Hex
Índice- 1. Introducción
- 2. Construcción del dispositivo
- 3. Programación del PIC la primera vez
- 3.1 Modificar el bootloader
- 3.2 Programando con WinPIC800
- 4. Programación y actualización del dispositivo
- 4.1 Modificar el PsGrooPIC
- 5. Uso
- 6. Solución de Problemas
- Anexos
- Anexo A: Versiones del PsGrooPIC
- Anexo B: Portando el código a otros microchips (18F4550)
1. IntroducciónA lo largo de esta guía vamos a tratar de explicar cómo se realiza exactamente un dispositivo USB que podremos utilizar después para grabar el exploit de ps3 PsGroopic. Nos vamos a basar en un microcontrolador PIC dotado de la lógica necesaria para gestionar un puerto USB.
Este tipo de circuitos son programables, por lo que se puede usar para infinidad de tareas. Para cambiar su finalidad basta con usar unas aplicaciones que quedan encapsuladas en archivos .hex, que podremos copiar y remplazar tantas veces como queramos dentro del dispositivo.
En este caso nos vamos a centrar en su aplicativo como Jailbreak para la PS3.
Además anotaremos como se puede modificar el software del PIC para que realice las funciones tal y como esperamos.
Esperamos que os sea útil.
2. Construcción del dispositivoTodo el circuito que estamos a punto de montar se basa en un microcontrolador PIC. Un PIC es un chip que contiene las funcionalidades de un ordenador, pero de una forma reducida y limitada. Este tipo de microcontroladores es programable gracias a una memoria interna que posee y consta de una serie de pines (las patillas) para comunicarse con el resto de componentes. El número de
patillas de un PIC varía según el modelo, algunas de estas tienen funciones ya
pre-asignadas y otras están libres para que el diseñador del circuito use con libertad.
Cada pin que tiene un PIC tiene un nombre, que a su vez define su funcionalidad. Los nombres de los pines se pueden ver buscando en Internet el datasheet del PIC que estamos manejando en cuestión. Si no estás familiarizado con los alias de los pines, es recomendable que busques en google el datasheet del PIC que vayas a utilizar. Por ejemplo, si es el PIC18F2550, deberíamos buscar "PIC18F2550 datasheet", y lo encontraremos rápidamente.
Hay diferentes tipos de microcontroladores PIC en el mercado que podrían servir a nuestra causa, pero los por ahora han sido probados y confirmados como válidos para poder manejar el PsGrooPIC son:
PIC18F2450
PIC18F2550
PIC18F4450
PIC18F4550
La serie 18F2xxx consta de 28 pines, mientras que la 18F4xxx consta de 40. Esto no es un problema ya que para la finalidad que queremos darle al chip, en ambas series tenemos los pines necesarios, cambiando solo la posición.
El esquema en sí, está basado en el expuesto por MetalPhreak en los foros de psx-scene (
http://psx-scene.com/forums/showthread.php?t=65863):
(para 18f2550 y para 18f4550)
Indicar que cuando una línea see cruza con otra, solo implica que hay conexión si existe un cuadrado rojo en la intersección.
La distribución de los componentes dentro de nuestro ensamblado no es importante, lo importante es que se hagan las conexiones que se marcan. Como nota, me gustaría añadir que el PIN RB5, debería ir a tierra cuando usamos para programarlo un ART2003 (LVP enabled).
Los componentes que se usan son:
- Zócalo de 28 pines (o 40 depende del caso)
- C1 y C2: dos condensadores de 22pf (o un poco más)
- C3 y C4: condensadores de 100 nf (pueden llegar a ser de hasta 470 nf)
- Q1: cristal de 20 Mhz (puede ser de 8Mhz, 12, 16 ó 24)
- R1 y R2: resistencias de 330 omnios (o 220 para tener más iluminación)
- R3 y R4: resistencias de 10 k
- LEDR y LEDG: un led rojo y otro verde de 0.5mm
- USB: una clavija de USB macho.
- Un jumper y pines para jumper
- Estaño
- Cable
- Soldador
- Placa perforada
Personalmente lo he montado en una placa perforada con las pistas premarcadas, y es una solución que os recomiendo. La distribución que he utilizado ha sido más o menos esta:
Los leds están cambiados en este último esquema. Solo recordar que tiene que apuntar el polo positivo (ánodo) a la resistencia y el negativo (cátodo a tierra). En la mayoría de los leds la patilla más larga es el ánodo, y si miras en su interior, hay como dos partes, la positiva es la parte más pequeña.
El conector USB da igual si es macho o hembra, el tipo, si se puede soldar a la placa o está en el aire, lo importante es tener bien los puntos y que se pueda conectar a la PS3. Si no usamos un macho tipo A, necesitaremos un cable que lo transforme en esto. Por ejemplo, si compramos una hembra tipo B necesitaremos un cable USB de macho Tipo A a macho tipo B. Por lo que recomiendo usar directamente un macho tipo A que se pueda soldar en la placa, para conectar el dispositivo directamente.
Dentro del USB, comúnmente tendremos este código de colores: el primer punto (cuadrado en lugar de circulo en los esquemas) es el cable rojo (VCC), el segundo el blanco (D-), el tercer punto el verde (D+) y el cuarto el cable negro que es tierra.
Las líneas azules son pequeños puentes realizados con cable. Uno por necesidad y el resto para poder customizar fácilmente el chip y que sea adaptable a otros bootloaders y demás configuraciones de los leds.
Para que os hagáis a la idea, el resultado final de mi placa es el siguiente (teniendo en cuenta que he modificado un poco la distribución de los componentes):
En este esquema, el Jumper está ahora en la parte inferior y al haberlo programado con un ART2003, el PIN 26 está unido con tierra. Los leds están en los pines 11 (RC0) y 12 (RC1). Esto no es importante, porque más adelante veremos cómo recompilar todo para que utilice estas posiciones de Leds. Si te estás preguntando donde está el cristal de cuarzo, se encuentra justo debajo del PIC, en la misma posición de los esquemas de más arriba. Además se puede observar que en el jumper, en lugar de poner solo dos
varillas, hay 3. Una de ellas no está conectada a nada, pero ayuda a no perder el jumper cuando se deje en modo de ejecución.
Una vez tengamos nuestro chip montado podemos pasar a programarlo…
3. Programación del PIC la primera vezLa primera vez que programemos el PIC vamos a utilizar un programador ART2003. Si buscáis por internet, encontrareis muchísimos diseños del mismo. Así que en esta parte no me voy a detener. Simplemente que sepáis que se puede utilizar un T20 y cualquier otro dispositivo semejante.
Lo que vamos a intentar hacer en este punto es cargar dentro del pic un programa llamado bootloader. Este bootloader se instala al principio de la memoria del microprocesador y mediante una pequeña señal, nos dejará instalar programas a continuación del mismo.
El bootloader arranca y si tiene un pin concreto activado entonces te deja programar lo que viene a continuación. Y si no, simplemente arranca el programa que se graba a partir de una posición de memoria determinada.
Algo importante a tener en cuenta es que cada bootloader tiene diferentes direcciones de memoria para asignar el programa de ejecución y a su vez diferentes pines para marcar el estado de programación.
Nosotros utilizaremos el USB HID C18 modificado, que almacena el programa .Hex a partir de la posición 0x1000 (luego tendrá importancia este valor), que usa los Leds en los pines rc0 y rc1; y el pin rb7 para marcar el estado de programación. Tal y como hemos realizado nuestra placa, este es el bootloader ideal, pero podríamos modificarlo para nuestras necesidades.
3.1 Modificar el bootloaderSi queremos modificar el bootloader para nuestra placa, lo primero que tenemos que hacer es ir a la página de MPLab y descargarnos el IDE (
http://www.microchip.com/stellent/idcpl ... t=SW007002) y el compilador para PIC18.
Después necesitaremos el código fuente del Bootloader, y usaremos el “BootloaderUSBHIDC18_18F2550Trainer_V1.0” que se puede encontrar en la página de PsGrooPIC (
http://psgroopic.blogspot.com).
Una vez tenemos todo instalado en nuestra máquina, nos dirigimos a la carpeta de código fuente del bootloader y abrimos el proyecto con el MPLab IDE.
Dentro de la ventana de workspace seleccionamos primero el archivo io_config.h. Este archivo está dividido en varias secciones que se pueden identificar gracias a los pragmas de compilación:
#if defined(MiE_PIC18F14K50Trainer)
...
#elif defined(MiE_PIC18F255xTrainer))
...
#elif defined(MiE_PIC18F455xTrainer)
...
#else
#error Not a supported board (yet), add I/O pin mapping in __FILE__, line __LINE__
#endif
Como en este caso estamos programando para un PIC18F2550, nos tendremos que mover hasta la sección de “
#elif defined(MiE_PIC18F255xTrainer)”.
Si por el contrario, vamos a usar otro PIC diferente al 2550, recomendaríamos leer ahora el Anexo B, para después seguir con los pasos que indicamos a continuación.
Dentro de esta sección debemos buscar la declaración de los LEDs, que debería ser algo así:
/** L E D ***********************************************************/
#define mInitAllLEDs() LATB &= 0xCF; TRISB &= 0xCF;
#define mLED_1 LATBbits.LATB5 //Red
#define mLED_2 LATBbits.LATB4 //Green
Aquí simplemente hay que cambiar los valores por los pines que usamos nosotros (RC0 y RC1):
/** L E D ***********************************************************/
#define mInitAllLEDs() LATC &= 0xCF; TRISC &= 0xCF;
#define mLED_1 LATCbits.LATC0 //Red
#define mLED_2 LATCbits.LATC1 //Green
Y justo encima de estas líneas añadimos una definición para nuestro Pin con jumper, en este caso el RB7:
/** JMP *************************************************************/
#define TRISJMPPIN TRISBbits.TRISB7
#define JMPPIN PORTBbits.RB7 //28 jumper
También puede resultar interesante comentar la líneas que hacen mención al switch para que no haya ningún problema con el C0, pero esto es opcional:
/** S W I T C H *****************************************************/
//#define mInitAllSwitches() TRISCbits.TRISC0=1;
//#define mInitSwitch() TRISCbits.TRISC0=1;
//#define sw PORTCbits.RC0
/********************************************************************/
Guardamos y cerramos este archivo, para a continuación abrir el “main.c”. Dentro de este archivo nos movemos hasta que el código sea algo parecido a esto:
void main(void)
{
if(RCONbits.POR == 1)
{
RCONbits.POR = 0;
}
else /*This example uses the sw I/O pin to determine if the device should enter the bootloader, or the main application code*/
{
RCONbits.POR = 1;
_asm
goto 0x1000 /*If the user is not trying to enter the bootloader, go straight to the main application remapped "reset" vector.*/
_endasm
}
…
Y lo sustituimos por este otro código:
void main(void)
{
ADCON1 = 0xF;
if(JMPPIN == 1)
{
ADCON1 = 0x7;
_asm
goto 0x1000
_endasm
}
…
Grabamos las modificaciones, compilamos y ya tenemos modificado nuestro bootloader para que funcione correctamente en nuestra placa.
3.2 Programando con WinPIC800Para poder programar correctamente el bootloader en el pic usaremos un programa llamado WinPIC800, que podéis descargar aquí (
http://www.winpic800.com/).
En la pantalla principal configuraremos el tipo de PIC que estamos usando:
Acto seguido, en el menú configuración > hardware, tendremos que elegir el ART2003:
Y ahora ya podemos abrir nuestro archivo .hex con el bootloader. Entonces hacemos clic en la pantalla de configuración y nos fijamos que el cristal tenga la frecuencia que utilizamos y que tenemos activado el LVP:
Ahora ya podemos lanzar el programar todo y después el verificar.
Si todas las tareas se han completado con éxito, ahora ya podemos colocar nuestro PIC en la placa y prescindir de otros programadores como el WinPIC y el ART2003. Nuestro dispositivo ya es programable y actualizable.
4. Programación y actualización del dispositivoPara poder tanto programar como actualizar el PsGrooPIC, simplemente pondremos el Jumper en posición de programación y lo conectamos al ordenador. Windows detectará el dispositivo como una interfaz HID USB.
Ahora descargamos el “Microchip Bootloader USB HID v2.6a”de la página del PsGrooPIC (
http://psgroopic.blogspot.com/) y lo ejecutamos:
El programa nos detectará nuestro dispositivo. Ahora hacemos clic en “Open Hex File” y seleccionamos nuestro archivo .hex con el psgroove, preparado para nuestro bootloader. Y después hacemos clic en “Program/Verify”. En unos pocos segundos nuestro PsGrooPIC estará correctamente programado.
Como nota añadir que es posible que se quede colgado durante el proceso de verificación (hay que tener en cuenta que este proceso es más bastante más largo que el de grabación y borrado). Esto no es importante siempre y cuando diga que se ha programado correctamente.
4.1 Modificar el PsGrooPICSi quieres saber cómo modificar un PsGrooPIC para cambiar los pines de los leds o activar el sector de arranque (aquello de la dirección de memoria 0x1000 del bootloader), necesitarás comprar el CCS PIC en su página oficial (
http://www.ccsinfo.com/).
Después deberías descargar el código fuente del exploit desde la página del PsGrooPIC (
http://psgroopic.blogspot.com/) y abrir el archivo “main.c” como un proyecto nuevo del CCS.
Nada más abrir el archivo “main.c” encontraremos estas líneas:
#include <18F2550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOBROWNOUT,USBDIV,PLL2,CPUDIV1,VREGEN,PUT,MCLR
#use delay(clock=48000000)
#use rs232(baud=115200, xmit=pin_c6, rcv=pin_c7)
#define LEDR PIN_B4
/////////////////////////
// Bootloader Memory Space
// Microchip USB HID Bootloader
#define CODE_START 0x1000
#build(reset=CODE_START, interrupt=CODE_START+0x08)
#org 0, CODE_START-1 {}
/////////////////////////
Aquí encontramos todo lo necesario para reconfigurarlo:
- Cambiar el valor del cristal: En la primera línea vemos el valor “PLL2”, esto significa que el cristal tiene 2x4 Mhz. Es decir, 8Mhz. Si hemos montado un cristal de 20, el PLL debería ser 5 (5x4 = 20 Mhz), por lo que sustituiríamos PLL2 por PLL5.
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,NOBROWNOUT,USBDIV,PLL5,CPUDIV1,VREGEN,PUT,MCLR
- Para nuesto bootloader es importante la dirección de memoria del comienzo del código (detrás del bootloader), como dijimos algo más arriba, este utiliza la posición 0x1000, por lo que debemos estar seguros de que esta línea existe con este valor:
#define CODE_START 0x1000
- El led queda definido en LEDR, y en este caso en el RB4 no tenemos ningún led, pero tenemos dos en el RC0 y RC1, por lo que añadimos una nueva línea (LEDG) y modificamos otra(LEDR):
#define LEDR PIN_C0 // Red
#define LEDG PIN_C1 // Green
Y buscamos a lo largo de todo el archivo, donde aparezca:
output_bit(LEDR,un_valor_cualquiera);
Cambiandolo por:
- si “un_valor_cualquiera” es led1, esto:
output_bit(LEDR,!led1);
output_bit(LEDG,led1);
- si en lugar de led1 pone un 1:
output_bit(LEDR,0);
output_bit(LEDG,1);
- si en lugar de 1 pone un 0:
output_bit(LEDR,1);
output_bit(LEDG,0);
Una vez hemos realizado nuestras modificaciones, compilamos y ya tenemos nuestro archivo .hex, listo para ser actualizado en nuestro dispositivo mediante el Microchip Bootloader USB HID.
5. UsoYa tenemos nuestro PsGrooPIC reprogramable listo, ahora deberíamos cambiar la posición del Jumper a modo funcionamiento (Modo “PS3” que digo yo) e introducirlo en uno de los puertos USB de nuestra consola.
Actualmente, el PsGrooPIC solo funciona (y exclusivamente) con el Firmware 3.41 de PS3.
Apagamos la PS3 desde el botón trasero, o desenchufándola de la red eléctrica. Esperamos unos segundos y la volvemos a conectar. Entonces se encenderá el piloto de “stand by”. Ahora rápidamente pulsamos el botón de “power” y justo después el de “eject” del blu-ray.
Observamos nuestro dispositivo y si después de que se enciendan varias veces las luces, la que queda encendida es la verde, significa que ha funcionado. Si no, repetir los pasos hasta que si que funcione.
6. Solución de ProblemasSi hemos realizado todos los pasos que se comentan en este documento y aún así no funciona nuestro dispositivo, lo primero que recomendamos es
revisar todas las soldaduras. Hay que ser muy cuidadoso y que no se junten unas con otras (si no es nuestra intención). Comprobar que cada punto va donde se espera y remarcar los bordes con el soldador para dejar bien separados los puntos.
Si sigue fallando, el siguiente paso será comprobar que no nos estamos confundiendo de
frecuencia del cristal. Si insertamos un .hex (ya sea el bootloader o el psgroopic) que no está preparado para la frecuencia de nuestro cristal, este simplemente no funcionará. Por lo que comprobar en el paso 3.2, que efectivamente se está insertando en el WinPIC800 el valor correcto de frecuencia y en el paso 4.1 que el valor PLL es realmente el que corresponde.
Incluso si después de comprobar todo (ves que tienes el
firmware 3.41 en la ps3), te sigue sin funcionar; siempre está este hilo para poder preguntar. Eso si, nos gustaría pedirte que la forma de consultar fuera lo más clara posible, danos los detalles de cómo realizas los pasos, que frecuencia de cristal tienes, que circuito has hecho, ...
AnexosAnexo A: Versiones del PsGrooPICEl PsGrooPIC es un port realizado por
J1M del
PsGroove basado en el trabajo de
ElSemi para microcontroladores PIC.
Versiones:
- 1.0 Primera release
- 1.1 Solucionados los problemas con el emulador BRD
- 1.2 Corregidos los problemas de los LEDs y añadida compatibilidad con el Microchip USB HID Bootloader
- 1.3 Añadidos los parches del lv2 (los de la nueva versión del psgroove)
- 1.4 Led cambiado a posición RB4 (solución a los problemas del LVP)
- 1.5 Añadido el payload de Hermes
Anexo B: Portando el código a otros microchips (18F4550)Todo este documento ha sido realizado con un PIC18F2550, pero eso no quiere decir que sea el único PIC que podemos usar. Adicionalmente, para cambiar el chip tendremos que hacer ciertas modificaciones en el código tanto del bootloader como del PSGrooPIC.
Para modificar el Bootloader y adaptarlo a otro chip (como el 18F4550) los pasos a dar serán:
- Descargar el archivo de linker para el 18f4550 (al final del anexo está la descarga y originalmente está dentro de las librerías de microchip que podéis descargar desde su página web)
- El el MPLAB IDE, con el código fuente del bootloader abierto tendremos que:
- Primero ir al menu Configure > Select Device, y dentro de la nueva ventana cambiar el device de 18F2550 por 18F4550
- En la ventana del Workspace, dentro de la carpeta de "Linker Script" quitamos el archivo "BootModified.18f2550_g.lkr" y añadimos el que acabamos de descargar, el "BootModified.18f4550_g.lkr".
- Ahora en el archivo de io_cfg.h, deberíamos hacer los cambios que se indican en el punto 3.1, pero esta vez dentro de la sección "#elif defined(MiE_PIC18F455xTrainer)".
Compilamos y tendremos nuestro bootloader preparado para el PIC18F4550.
Y para modificar el PsGrooPIC (creo que si hacéis la prueba, funcionará la misma versión que para el 18F2550), solo tendríamos que cambiar la primera línea del archivo main.c:
En lugar de:
#include <18F2550.h>
Debería poner:
#include <18F4550.h>
Compilamos con el CCS y ya temos nuestro PsGrooPIC preparado para otro chip diferente
BootloaderUSBHIDC18_18F4550Trainer_V1.0 - customized by nullex.hex.zipBootModified.18f4550_g.lkr.zip 
![[oki]](/images/smilies/net_thumbsup.gif "Ok!")
![[qmparto]](/images/smilies/net_quemeparto.gif "Que me parto!")
), realice el cambio que me comentabas ![[buuuaaaa]](/images/smilies/nuevos/triste_ani3.gif "a lágrima viva")
