Progetto segreto

Sto lavorando ad un progetto molto importante su psp di cui non posso rivelare ulteriori dettagli, cito solo alcune parole: hack univerale!

[EXPLOIT] Gioco anonimo by Team Dark_Shadow!

Il nostro team ha scoperto un exploit su di un gioco che è uscito tempo fa, stiamo alvorando con magixien ed altri per cercare di concludere il lavoro e così avviare homebrew

[SOURCE] 5.50 GEN-D3 semi-completo!

I have released the source code of 5.50 gen-d3. I have decompiled the PRX, but I haven't fixed the source ;)

Ho rilasciato il file sorgente del 5.50 gen-d3. Ho decompilato i PRX, ma non ho aggiustato il sorgente ;)

DOWNLOAD: No - Private
DOWNLOAD: 8 HEADER incomplete - NOT COMPLETE

[PSPLINK] Guida all'utilizzo

********************
* XMB Istruzioni *
********************

1) Estrarre l'archivio RemoteJoy e copiare la PSP / PSPLink cartella per il vostro
MemoryStick. Dovrebbe finire come ms0: / PSP/GAME340/PSPLink Questo è il presupposto che
si esegue Dark_Alex's Custom Firmware 3.40 OE-A!

2) Copia la cartella PSPLink dalla PSP FW 3XX cartella di OE alla vostra
ms0: / PSP/GAME340 cartella.

3) Copia psplink.prx e remotejoy.prx dalla cartella seplugins al tuo
ms0: / cartella seplugins. Aggiungere le righe in game.txt al tuo game.txt. Se lo fate
non hanno un game.txt nel tuo ms0: / seplugins cartella, quindi basta copiare l'uno
Ho fornito.

*** Nota ********************************************** **********************
È necessario aver installato i driver di Windows LibUSB prima di poter fare qualsiasi cosa
più avanti! Farlo adesso, se non avete.

Vedere la ReadMe-LibUSB.txt per le indicazioni su come installarli. È necessario
hanno corretto le chiavi IDStorage per questo per funzionare correttamente! Info è in quel file.
************************************************** ***************************

5) Una volta che hai tutto quello che costante è il momento di eseguire le applicazioni. Hanno la cartella
aperto con la mazza. file pronti.

Fare doppio clic su Start-USBHostFS_PC.bat

6) Accendere la PSP e andare a giochi ed eseguire l'icona PSPLink OE. L'applicazione sarà
Start sulla tua PSP e lo schermo diventa nero con una riga di testo. Si dovrebbe
Ora assistiamo a un "Connected to Device" linea nella finestra di usbhostfs_pc.exe comando.

7) Fare doppio clic su Start-PSPSH.bat

8) Fare doppio clic su uno dei seguenti:

Start-RemoteJoy.bat - per una finestra
Start-RemoteJoy-FPS.bat - per una finestra con display FPS
Start-RemoteJoy-FS.bat - per fullscreen
Start-RemoteJoy-FS-FPS.bat - per la visualizzazione a schermo intero con FPS

È possibile premere ESC nella finestra o in modalità a schermo intero per uscire Remote Joy SDL

9) Nel tipo pspsh.exe finestra i seguenti comandi:

loadvsh% (PSPLink uscirà su PSP e la Cross Media Bar si caricherà)

loadjoy% (Your Cross Media Bar sarà visualizzato nella finestra RemoteJoy)

Si dovrebbe essere in grado di vedere il vostro schermo della PSP in una finestra ora. Si blocca quando
si entra nel menu Video sulla XMB e se / quando si esegue qualsiasi cosa tu perderai
il link.

Non si vuole avere la psplink.prx e plugin remotejoy.prx attivato in
il ripristino di menu se si desidera utilizzare PSPLink 3,0 OE.


*********************
* Istruzioni di gioco *
*********************


Per impostare questa funzione in modo da poter visualizzare i giochi sullo schermo del vostro PC avrete bisogno di fare il
seguenti:

1) Attiva entrambe le plugins (psplink.prx e remotejoy.prx) tramite il Menu di recupero.
Per arrivarci è sufficiente tenere premuto il tasto destro fino alla spalla durante il boot
la tua PSP.

2) Se i passaggi 5, 7 e 8 di cui sopra. Passaggio 6 e 9 non sono necessari per questo dal momento che
sono auto caricare il prx.'s attraverso il Custom Firmware.

Non è garantito il funzionamento di ogni gioco e se avete qualche altro. Prx
esecuzione si potrebbe incorrere in problemi. Se un gioco utilizza una chiamata a carico di talune
file / directory al largo della memory stick che è incompatibile con PSPLink,
la tua PSP si blocca. Fondamentalmente sta andando a prendere un sacco di tentativi ed errori
per capire quali giochi e altri. prx la volontà di lavorare con questo.



Video dimostrativo: http://www.youtube.com/watch?v=1U56xk6ZvEo&feature=player_embedded

Presto il download, oppure cercate su Google "download psplink 3.0"

[EXPLOIT] PSPgo memory by Malloxis

Thank you Malloxis. In questo video msotra con un exploit che riesce ad accendere la spia w-lan e mostra che cliccano sulle varie icone della XMB che non si toglie e che è un vero exploit. Dice che non lo rilascerà mai, però dato che è molto buono lo spero tanto, vorrei tanto aiutarlo ma tocca a lui scegliere.
Malloxis, you are the best!

VIDE LINK: http://www.youtube.com/v/aX5IC-V2EQE

Vi ricordo che lui è il cretore dell'exploit 5.03 libtiff e del MOHH exploit ;)

[C] Guida sulle VLF

Presa da un pdf francese.

(AGGIUNGERE PARANTESI TRINAGOLARI AGLI HEADER)

#include pspsdk.h
#include pspkernel.h
#include pspusb.h
#include pspusbstor.h
#include pspctrl.h
#include psppower.h
#include psprtc.h
#include psputils.h
#include pspusbdevice.h
#include systemctrl.h
#include stdlib.h
#include string.h
#include stdio.h
#include stdarg.h
#include vlf.h
#include "main.h"

PSP_MODULE_INFO("VLF_Sample", 0, 1, 0);//PSP_MODULE_INFO(NOM_DE_LAPPLICATION, Mode, Version_Minor, Version_Major);
PSP_MAIN_THREAD_ATTR(0);

void *ReadFileAllocEx(char *file, int seek, int size, int *retSize);
void *malloc64(int size);

VlfText title = -1;
VlfText titlemenu = -1;

int OnCrossPress()
{

vlfGuiSetBackgroundPlane(0xFF000000);

return VLF_EV_RET_REFRESH_ON_DELAY;
}


int OnBackToMainMenu(int enter)
{
if (!enter)
{
int i;
vlfGuiRemovePicture(pic);

for(i = 0; i < N_HI_ITEMS; i++)

vlfGuiRemoveText(hi_texts[i]);


//vlfGuiCancelCentralMenu();

vlfGuiCancelBottomDialog();

vlfGuiRemoveEventHandler(OnCrossPress);

MainMenu(0);
}

return VLF_EV_RET_NOTHING;
}

//Fonction OptionsMenu1
void OptionsMenu1(int sel)
{
int i;

//Ajoute les text suivant a l'ecran
hi_texts[0] = vlfGuiAddText(60, 60, "VLF esempio");
hi_texts[1] = vlfGuiAddText(80, 80, "per i developer");
hi_texts[2] = vlfGuiAddText(80, 100, "grazie alle lib vlf di D_A");
hi_texts[3] = vlfGuiAddText(100, 120, "Enjoy");


for(i = 0; i < 4; i++)

vlfGuiBottomDialog(VLF_DI_BACK, -1, 1, 0, VLF_DEFAULT, OnBackToMainMenu);
}


void OptionsMenu2(int sel)
{

pic = vlfGuiAddPictureResource("topmenu_icon", "tex_system", 50, 50);


vlfGuiAddEventHandler(PSP_CTRL_CROSS, 0, OnCrossPress, NULL);

vlfGuiCustomBottomDialog("Precedent", "Changer la couleur", 1, 0, 150, OnBackToMainMenu);
}

int OnMainMenuSelect(int sel)
{

switch(sel)
{
case 0:
vlfGuiCancelBottomDialog();
vlfGuiCancelCentralMenu();
OptionsMenu1(0);
break;
case 1:
vlfGuiCancelBottomDialog();
vlfGuiCancelCentralMenu();
OptionsMenu2(0);
//return VLF_EV_RET_NOTHING;//Re
break;
case 2:
sceKernelExitGame();
return VLF_EV_RET_REMOVE_OBJECTS | VLF_EV_RET_REMOVE_HANDLERS;
break;
}

return VLF_EV_RET_NOTHING;
}

//Fontion MainMenu
void MainMenu(int sel)
{
titlemenu = vlfGuiAddText(0, 20, "Menu Principal");
vlfGuiSetTextFade(titlemenu, VLF_FADE_MODE_REPEAT, VLF_FADE_EFFECT_SLOW, 0);

char *items[] =
{
"Options 1",
"Options 2",
"Quitter"
};

/*Construction et affichage du menu principal
vlfGuiCentralMenu(1, 2, 3, 4, 5, 6);
(1:Nombre d'options dans le menu,
2:Pointeur de type char* "caract�re" pour r�cup�re les caract�res pour le menu,
3:Position du curseur par d�faut au d�marrage (0= Toggle USB),
4:Fonction pour utiliser le menu,
5:Disposition du menu en longueur de droite � gauche,
6:Disposition du menu en hauteur de haut en bas*/
vlfGuiCentralMenu(3, items, sel, OnMainMenuSelect, 2, 50);

vlfGuiBottomDialog(-1, VLF_DI_ENTER, 1, 0, VLF_DEFAULT, NULL);
}

//Fontion app_main
int app_main()
{
void *bi;
u32 rnd;
u64 tick;
SceKernelUtilsMt19937Context ctx;

sceRtcGetCurrentTick(&tick);
sceKernelUtilsMt19937Init(&ctx, (u32)tick);
rnd = sceKernelUtilsMt19937UInt(&ctx) % 12;

void *data = ReadFileAllocEx("flash0:/vsh/resource/01-12.bmp", rnd*6176, 6176, NULL);
vlfGuiSetBackgroundFileBuffer(data, 6176);


if (!data || vlfGuiSetBackgroundFileBuffer(data, 6176) < 0)
vlfGuiSetBackgroundPlane(0xFF000000);//Ajoute une couleur noir


if(data)
free(data);

vlfGuiCacheResource("system_plugin");
vlfGuiCacheResource("system_plugin_fg");


title = vlfGuiAddText(0, 0, "VLF Sample by Zer01ne");

vlfGuiSetTitleBar(title, -1, 1, 0);

vlfGuiAddPictureResource("sysconf_plugin", "tex_bar_init_icon", 4, -2);

vlfGuiSetModelSystem();

vlfGuiAddBatteryIconSystem(&bi, 10*1000*1000);

vlfGuiAddClock();

MainMenu(0);

//Boucle infini de type while
while(1)
{
vlfGuiDrawFrame();
}

return 0;
}

MAKEFILE

TARGET = VLF_Sample
OBJS = crt0.o main.o

INCDIR =
CFLAGS = -O2 -G0 -Wall -fshort-wchar -fno-pic -mno-check-zero-division
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS) -c

LIBDIR =
LDFLAGS += -nostdlib -nodefaultlibs
LIBS = -lpsprtc -lvlfgui -lvlfgu -lvlfutils -lvlflibc

EXTRA_TARGETS = EBOOT.PBP

PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak

[HELP] Spiegazione parole programmazione

Eco che spiego le parole del linguaggio e cosa significano:

HEADER = Le librerie che si trovano all'interno di pspsdk/include.
MAIN = Il codice principale su cui si fa riferimento(file sorgente).
CALLBACK = Il comando che permette di premere HOME e uscire dalla PSP.
MAKEFILE = Il codice di configurazione che permette di compilare per bene il codice aggiungendo LIBS ed altro.
LIBS = librerie aggiuntive per nuovi codici dentro il file sorgente.
DECRYPTARE = Togliere la fimra, in questo caso Sony e poter visualizzare contenuti come scritte.
DECOMPILARE = Estrarre il source code/file sorgente da un PRX o ELF nel caso della PSP.
CRYPTARE = Rimette la firma della Sony (per farlo bisogna reversare il KIRK ed è illegale)
COMPILARE = Firmare il codice con la tua firma e avviarlo.
REVERSE = Ottenere il codice come "DECOMPILARE"

Mandatemi un messaggio o un commento per cheidermi altre parole e le aggiungerò ;)

[C] AdHoc Guide/Esempi

Ciao a tutti, vi presento una specie di guida sull'AdHoc così potrete creare de vostri homebrew giocabili in 2 o più. Vi ricordo che quetsa guida non è mia ma di un utente inglese di un altro forum.
Incominiamo con l'aggiungere gli header:

(Aggiungete ad ogni header le parentesi triangolari)

HEADER

#include pspkernel.h
#include pspmodulemgr.h
#include pspdisplay.h
#include pspdebug.h
#include pspthreadman.h
#include pspctrl.h
#include pspsdk.h
#include stdio.h
#include stdlib.h
#include string.h

#define printf pspDebugScreenPrintf

/* 0x1000 = kernel mode set */
PSP_MODULE_INFO("AdHoc", 0x1000, 0, 1);
/* user mode */
PSP_MAIN_THREAD_ATTR(0);

Ora aggiungiamo i callback:

EXIT CALLBACK THREAD

/* exit callback */
int exit_callback(int arg1, int arg2, void *common){
adhocTerm();
sceKernelExitGame();
return 0;
}

/* callback thread */
int CallbackThread(SceSize args, void *argp){
int cbid;
cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
sceKernelRegisterExitCallback(cbid);
sceKernelSleepThreadCB();
return 0;
}

/* debug output */
void sdl_psp_exception_handler(PspDebugRegBlock *regs){
pspDebugScreenInit();

pspDebugScreenSetBackColor(0x00FF0000);
pspDebugScreenSetTextColor(0xFFFFFFFF);
pspDebugScreenClear();

printf("oh **** BSOD...\n\n");
printf("Exception Details:\n");
pspDebugDumpException(regs);
printf("\nPut this in your cygwin and smoke it:\n\n"
"\tpsp-addr2line -e target.elf -f -C 0x%x 0x%x 0x%x\n",
regs->epc, regs->badvaddr, regs->r[31]);
}

/* setup the callback thread */
int SetupCallbacks(void){
int thid = 0;
thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, 0, 0);
if(thid >= 0)
sceKernelStartThread(thid, 0, 0);
return thid;
}

Ora incominciamo con ESEMPI:

ALPHABET

int user_main(SceSize args, void *argp){

/* var init */
int done, err, i, loop, server, size = 0;
unsigned int length;
char *data;
SceCtrlData pad;

pspDebugScreenInit();

/* adhoc initalise functions */
if((adhocInit("") >= 0) && ((server = adhocSelect()) >=0)){
printf("\n\n## AdHoc INITALISED ##\n\n");
sceKernelDelayThread(1000000);

/* Display server, or client */
if(server)
printf("Server Assigned\n\n");
else
printf("Client Assigned\n\n");

/* if this psp is the server */
if(server){
/* client must be waiting for server, so slight delay for server */
sceKernelDelayThread(1000000);
/* alphabet string */
data = "abcdefghijklmnopqrstuvwxyz";
size = sizeof(data);

printf("Sending data to the client.. size: %d \n", size);
err = adhocSendRecvAck(&size, 4); /* let client know the size of data */
printf("Done sending size: %d\ndata: %s\n", size, data);

sceKernelDelayThread(1000000);

err = adhocSendRecvAck(&data, 4); /* send data as void */
printf("Done sending data: %s\nsize: %d\n", data, size);
} else {
printf("Waiting for data..\n");

/* get data from server */
size = 0;
length = 4;
err = adhocRecvSendAck(&size, &length); /* get size of data */
printf("Done receiving size: %d \nlength: %d \n", size, length);

length = size;
err = adhocRecvSendAck(&data, &length); /* get data */
data = (char *)data; /* type cast received data */
printf("Received data from server: %s \n", data);
}
}
/* terminate adhoc */
adhocTerm();

printf("Press START to exit..\n");
done = 0;
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != 0)
if(pad.Buttons & PSP_CTRL_START)
done = 1;
} while(!done);

}

DATA STREAM

int user_main(SceSize args, void *argp){

SetupCallbacks();

static char buffer[0x8000];
unsigned int length;
int err, bD = 0;
int i, done, mainDone, server=0;

char *data;
int size = 0;

SceCtrlData pad;

pspDebugScreenInit();

do {

if((adhocInit("") >= 0) && ((server = adhocSelect()) >=0)){

pspDebugScreenPrintf("\n\n## AdHoc INITALISED ##\n\n");

sceKernelDelayThread(1000000);

if(server)
pspDebugScreenPrintf("Server Assigned\n\n");
else
pspDebugScreenPrintf("Client Assigned\n\n");

if(server){
sceKernelDelayThread(5000000);
done = 0;
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != 0)
if(pad.Buttons & PSP_CTRL_CROSS)
done = 1;

if((i % 2) == 0){
data = ".";
i = 0;
} else
data = "|";
i++;

if(done == 1)
data = "x";
size = sizeof(data);

err = adhocSendRecvAck(&size, 4);
err = adhocSendRecvAck(&data, 4); //# send data

pspDebugScreenPrintf("%s", data);
} while(done==0);

} else {
done = 0;
do {
/*sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != 0)
if(pad.Buttons & PSP_CTRL_CROSS)
done = 1;*/

size = 0;
length = 4;
err = adhocRecvSendAck(&size, &length);

length = size;
err = adhocRecvSendAck(&data, &length);
data = (char *)data;

if(data == "x")
done = 1;

pspDebugScreenPrintf("%s", data);
} while(done==0);

}

}

pspDebugScreenPrintf("\n\n");

adhocTerm();

done = 0;
pspDebugScreenInit();
pspDebugScreenPrintf("\n\nPress START to Exit, X to Continue\n\n");
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != 0){
if(pad.Buttons & PSP_CTRL_START){
done = 1; mainDone=1;
sceKernelExitGame();
}
if(pad.Buttons & PSP_CTRL_CROSS)
done = 1; mainDone=0;
}
} while(!done);

} while(!mainDone);

/* pspDebugScreenPrintf("Press any key to exit..\n");
done = 0;
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != 0)
done = 1;
} while(!done);*/

sceKernelExitGame();
}

MAIN

/* kernel mode thread */
int main(int argc, char *argp[]){

/* exit callback */
SetupCallbacks();

/* load adhoc modules */
if (adhocLoadDrivers(&module_info) != 0){
printf("Driver load error\n");
return 0;
}

/* setup debug info handler */
pspDebugInstallErrorHandler(sdl_psp_exception_handler);

/* create user thread */
SceUID thid = sceKernelCreateThread("User Mode Thread", user_main,
0x11, // default priority
256 * 1024, // stack size (256KB is regular default)
PSP_THREAD_ATTR_USER, NULL); //# user mode

// start user thread, then wait for it to do everything else
sceKernelStartThread(thid, 0, 0);
sceKernelWaitThreadEnd(thid, NULL);

/* quick clean exit */
sceKernelExitGame();

return 0;
}

Ed infine, improtante, il makefile.mk:

MAKEFILE

TARGET = adhoc
PSPSDK=$(shell psp-config --pspsdk-path)
PSPBIN = $(PSPSDK)/../bin

OBJS = main.o

OBJS += ad-hoc/selectorMenu.o \
ad-hoc/loadutil.o \
ad-hoc/pspadhoc.o \
ad-hoc/stubs.o

INCDIR =
CFLAGS = -g -O2 -G0 \
-I. -Icpu -Ipsp -DLSB_FIRST \
-DALIGN_DWORD -DDOS -DPSP -DUSE_ZLIB
CXXFLAGS = -g $(CFLAGS) -fno-exceptions -fno-rtti -Wpointer-arith
ASFLAGS = -c $(CFLAGS)

LIBDIR =
LDFLAGS =
LIBS = -lpspgu -lpspwlan -lpsppower -lz -lstdc++ -lm

#EXTRA_TARGETS = kxploit
PSP_EBOOT_TITLE = Adhoc

include $(PSPSDK)/lib/build.mak

Grazie all'adhoc potete creare una specie di messaging tra utenti vicini o grazie ai programmi che trasformano l'adhoc in online tipo adhoc party o xlink kai potrete chattare o giocare con il vostro gioco che creerete.

Fonte: PSP-PROGRAMMING

[C] Creare un Timer

Iniziamo con qualcosa di semplice oggi...Un Timer che conta i secondi!
Incominciam ad aggiungere gli header all'interno del vostro progetto

#include
#include

Aggiungiamo il nome della value

//ESEMPIO (Psuedo Code)
//QUESTI 2 SLASH SONO COMMENTI INUTILI PER IL PROGRAMMA
type name=value;

E stampiamo la scritta come qui sotto:

printf("Premi [X] per avviare il timer");

Incominciamo ad aprire il ciclo:

while(1) {

Aggiungiamo un reader e il comando che servirà per azionare il timer, per esmepio la X (potete cambiarlo con /_\ come: PSP_CTRL_TRIANGLE oppure in altro)

sceCtrlReadBufferPositive(&pad, 1);

if(pad.Buttons & PSP_CTRL_CROSS) {
break;
}
}

Apriamo il prossimo ciclo per fermare poi il nostro timer e dirci il risultato:

while(1) {

Avviamo un altro reader e il comando O per fermarlo

sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CIRCLE) {
break;
}

pspDebugScreenClear();

Aggiungiamo la riga di testo per dire che con O si ferma:

printf("Premi [O] per fermare il timer\n");
printf("Contatore: %i", counter);
counter++;

for(i=0; i<5; i++) {
sceDisplayWaitVblankStart();
}
}

Ed infine ultimo codice che presenterà il numero fatto:

pspDebugScreenClear();
printf("Timer concluso");
printf("Il conto finale è: %i", counter);

[HB DEMO] Go!Snake v0.1 by Andrea1234567890

Ieri mi era venuto in mente di creare un homebrew game anche se più complicato l'ho voluto incominciare in C. Per ora è una demo, quindi non potete fare punti e giocare normarlamente. Ora potete solo muovermi e fare una scia, vi dirò i comandi.

R = velocizzare il serpente
L = rallentare il serpente
Triangolo = fare la scia del serpente
X = muovere il serpente
Tasti direzionali = direziona il serpente.

Ecco la demo beta.

DOWNLOAD

[HACK] Ecco come crypta il KIRK!

This page will be used to document the KIRK Crypto Engine and will be updated as new info is learned (data may change).

The KIRK Crypto Engine is a security hardware device that is embedded into the TACHYON main IC chip. It is a bus master and can DMA to/from main DDR RAM memory, operating independantly of the CPU. It is intefaced via memory mapped registers at base of 0xBDE00000 (SPOCK on the other hand is mapped to 0xBDF00000).

It is capable of performing AES encryption, SHA1 Hash, and random number generation.

KIRK Operations (set in 0xBDE00010 register):


1.
// Private Sig + Cipher
2.
0×01: Super-Duper decryption (no inverse)
3.
0×02: Encrypt Operation (inverse of 0×03)
4.
0×03: Decrypt Operation (inverse of 0×02)
5.

6.
// Cipher
7.
0×04: Encrypt Operation (inverse of 0×07) (IV=0)
8.
0×05: Encrypt Operation (inverse of 0×08) (IV=FuseID)
9.
0×06: Encrypt Operation (inverse of 0×09) (IV=UserDefined)
10.
0×07: Decrypt Operation (inverse of 0×04)
11.
0×08: Decrypt Operation (inverse of 0×05)
12.
0×09: Decrypt Operation (inverse of 0×06)
13.

14.
// Sig Gens
15.
0×0A: Private Signature Check (checks for private SCE sig)
16.
0×0B: SHA1 Hash
17.
0×0C: Mul1
18.
0×0D: Mul2
19.
0×0E: Random Number Gen
20.
0×0F: (absolutely no idea – could be KIRK initialization)
21.
0×10: Signature Gen
22.

23.
// Sig Checks
24.
0×11: Signature Check (checks for generated sigs)
25.
0×12: Certificate Check (idstorage signatures)

KIRK Errors (returned in 0xBDE00014 register):

1.
0×00: Operation Success, no error
2.
0×01: KIRK not enabled
3.
0×02: Invalid mode
4.
0×03: Header check invalid
5.
0×04: Data check invalid
6.
0×05: Sig Check failed
7.
0×06:
8.
0×07:
9.
0×08:
10.
0×09:
11.
0×0A:
12.
0×0B:
13.
0×0C: KIRK not initialized
14.
0×0D: Invalid Operation (1-18 cmds)
15.
0×0E: Invalid seed/code (cipher operations)
16.
0×0F: Invalid size? (cipher operations)
17.
0×10: Data Size is 0 (sig/cipher operations)

Interface to KIRK device (memory mapped to 0xBDE00000):

1.
typedef volatile struct
2.
{
3.
u32 signature;
4.
u32 version;
5.
u32 error;
6.
u32 proc_phase;
7.
u32 command;
8.
u32 result;
9.
u32 unk_18;
10.
u32 status;
11.
u32 status_async;
12.
u32 status_async_end;
13.
u32 status_end;
14.
u32 src_addr;
15.
u32 dst_addr;
16.

17.
} PspKirkRegs;
18.

19.
#define MAKE_PHYS_ADDR(_addr) (((u32)_addr) & 0×1FFFFFFF)
20.
#define SYNC() asm("sync")
21.

22.
#define KIRK_HW_REGISTER_ADDR ((PspKirkRegs *)0xBDE00000)
23.

24.
u32 DecryptKirkBlock(void *dst, const void *src)
25.
{
26.
sceKernelDcacheWritebackInvalidateAll();
27.

28.
PspKirkRegs *const kirk = KIRK_HW_REGISTER_ADDR;
29.

30.
kirk->command = 1; // decrypt operation
31.
kirk->src_addr = MAKE_PHYS_ADDR(src);
32.
kirk->dst_addr = MAKE_PHYS_ADDR(dst);
33.

34.
kirk->proc_phase = 1; // start processing
35.

36.
while((kirk->status & 0×11) == 0); // wait until processing complete
37.

38.
if (kirk->status & 0×10) // error occured
39.
{
40.
kirk->proc_phase = 2;
41.

42.
while((kirk->status & 2) == 0);
43.

44.
kirk->status_end = kirk->status;
45.
SYNC();
46.
return -1;
47.
}
48.

49.
kirk->status_end = kirk->status;
50.
SYNC();
51.
return(kirk->result);
52.
}

[EXPLOIT] Com'è strutturato Pandora exploit?

A causa di troppe informazione sbagliata e speculazione generale questa pagina sarà una documentazione adeguata dell'impresa della Pandora (la stessa impresa usata per CFW).
Per ora esso sia appena una copia-colla diritta di un alberino che ho fatto sulle tribune di QJ (sarà aggiornato con più Info successivamente): Sì il blocco era abbastanza piccolo alla forza bruta (quindi perché non potreste firmare un intero EBOOT, devono la forza bruta l'intero affare).
La chiave riservata non bruteforced comunque (non quel importerebbe se fosse comunque, le procedure è ancora sconosciuto). Come gli impianti di decryption è questo, i dati in primo luogo sono cifrati ed allora i dati cifrati sono firmati. Una volta passati al motore crypto, in primo luogo controllano la firma e se è valido decifreranno i dati (procedure per entrambi il & di crittografia; la firma è sconosciuta, non quello che so di comunque, forse qualcuno sa… o non). I dati cifrati falsi bruteforced per decifrare nei vostri dati scelti (per potere sfruttare il preipl). E la firma per i vostri dati cifrati falsi bruteforced ancora per farlo sembrare validi secondo il motore crypto in modo che voglia vada avanti e decifri i vostri dati cifrati falsi. L'impresa del preipl funziona come questa: In primo luogo un blocchetto decifrato di ipl: 0×00: indirizzo del carico 0×04: formato di dati 0×08: indirizzo dell'entrata 0×0C: totale di controllo del blocco precedente 0×10: dati Un esempio tipico ha potuto essere
0×040F1EA0
0×00000F50
0×00000000
0xB71C6EBA
… dati…
Quale significa i dati del carico 0xF50-byte a 0×040F1EA0. 0xB71C6EBA è il totale di controllo del blocco precedente. Allora l'indirizzo dell'entrata è 0 poiché non ha raggiunto l'estremità tuttavia e ci sono più blocchi da caricare. Una volta che ha caricato il tutto il ipl ostruisce il blocco ultimo avrà indirizzo dell'entrata di dove l'intero ipl è stato caricato (tipicamente 0×040F0000). Ed allora salterà a quell'indirizzo. Pseudocode di Preipl per il & di caricamento;

decifrare il ipl:

1.
int iplBlockNumber = 0;
2.
u32 checksum = 0;
3.

4.
// load/decrypt all encrypted ipl blocks
5.
while(1)
6.
{
7.
// copy an encrypted ipl block to 0xBFD00000-0xBFD01000 (4KB embedded cpu ram)
8.
if (LoadIplBlock(iplBlockNumber, block) <0)
9.
while(1);
10.

11.
// decrypt the ipl block in place (uh oh…)
12.
if (DecryptIplBlock(block, block))
13.
while(1);
14.

15.
// first block will have zero as its checksum since there is no previous block (another uh oh…)
16.
if (block->checksum != checksum)
17.
while(1);
18.

19.
// load the ‘data’ section of the ipl block to the specified address (0×040Fxxxx range)
20.
if (block->loadaddr)
21.
checksum = memcpy(block->loadaddr, block->data, block->blocksize);
22.

23.
// reached the end of the ipl, jump to the entry address (0×040F0000)
24.
if (block->entry)
25.
{
26.
// clear caches
27.
Dcache();
28.
Icache();
29.

30.
// jump to ipl – do not return
31.
block->entry();
32.
}
33.

34.
iplBlockNumber++;
35.
}

Mentre il preipl carica il primo blocchetto di ipl (quello falso), decifra il blocco sul posto, IE. il blocco decifrato scrive sopra appena il vostro blocco cifrato. I decrypts falsi del blocco soltanto in quattro byte di esso di tutto e 0 le così conclude in su soltanto la sovrascrittura dei primi quattro byte del vostro blocco falso (con quattro 0) dopo il decryption.

Il blocco firmato falsificato:

1.
00000000: 00 00 00 00 00 00 00 00 00 01 D0 BF 00 00 00 00
2.
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
3.
00000020: 52 A1 05 CD 3A 52 59 28 0A D1 31 F1 BD 87 2E CC
4.
00000030: 14 DA 02 2F 77 88 C7 66 F3 32 07 BD 1A 08 9E 4C
5.
00000040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
6.
00000050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
7.
00000060: 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
8.
00000070: 04 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00
9.
00000080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10.
00000090: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
11.
000000A0: 00 00 00 00 00 00 00 00 00 00 00 01 C6 5F 74 12

La maggior parte della parte importante alla nota: 0×20-0×3F è le firme bruteforced del hash 0xA0-0xAF è i dati cifrati bruteforced 0×70-0×73 è il formato dei dati decifrati (soltanto 4 byte) Un leggero difetto nel motore crypto ha permesso che la forza bruta fosse effettuata sull'grandezza-tempi su scala ridotta che richiesto normalmente. Dopo decryption, il preipl pensa che i dati ora siano un blocchetto decifrato di ipl. Così noti i primi byte 0×10: 0×00000000 (indirizzo del carico che è stato simulato a quattro 0 una volta decifrato) 0×00000000 (formato del blocco al carico, nessuno) 0xBFD00100 (l'indirizzo dell'entrata, la maggior parte della parte importante, dove il vostro codice senza firma è individuato) 0×00000000 (totale di controllo) Supera la prova di totale di controllo (con 0×00000000), esso salta il caricamento di tutti i dati (poiché il loadaddr è stato simulato a 0×00000000), ha veduto l'indirizzo dell'entrata di 0xBFD00100 e pensa che abbia raggiunto la conclusione del ipl ed in modo da vada salti a quell'indirizzo (che è dove il vostro codice senza firma sarà). In modo che sia essenzialmente in breve. Ma non lasci un sommario rapido di 5 min. del underestimate che di impresa lo sforzo enorme ha coinvolto nel portarlo a compimento (come i prodotti finiti conosciuti come Pandora).

Traduttore: babelfish

[LUA] Guida Perfetta - Hello World

Adesso vi speigo come fare un hello world in LUA e vi spiego passo passo a che servono le relative funzioni:

1.Per prima cosa questo è un hello world:

bianco = Color.new(255,255,255)
while true do
screen:print(7,7,"hello world",bianco)
screen:flip()
screen:waitVblankStart()
end

2.Per prima cosa "bianco = Color.new(255,255,255)" è il codice del colore che va' messo per primo nel ".lua".
*BIANCO è il nome a cuoi volete dare al colore (potete chiamarlo anche white ecc.)
*Color.new è la funziona di Nuovo Colore nel ".lua"
*(255,255,255) è il colore, che potete trovare andando su Paint e andate ai colori e a fianco troverete



3. con while true do incomincia il ciclo dell'hello world, che si mette molto spesso dopo il colore

4. Ecco qui che possiamo stampare la nostra scritta "hello world" ... Il codice era: screen:print(150,40,"hello world",bianco)
*screen:print è il codice che permette di STAMPARE sullo schermo della PSP una scritta.
*150,40 è la posizione in qui la scritta sarà. Il primo numero si riferisce all'asse X(cioè orizzontale) e il secondo all'asse Y(cioè verticale)
*"hello world" è la scritta la quale apparirà sullo schermo della PSP nella posizione scelta (per andare a capo scrivere /n)
*bianco è il colore, come detto precedentemente creato, in questo caso bianco ma potete creare nero, rosso, giallo, blu, verde, ecc..

5. screen:flip()
screen:waitVblankStart()

Questi 2 codici permettono la visualizzazione riuscita alla perfezione su schermo che si mette ad ogni fine ".lua"

6. end il codice per finire il primo ciclo (che può essere anche l'ultimo)

[Degli esempi di colori sono nero(0,0,0) rosso(255,0,0) giallo(0,255,0) blu(0,0,255)]

[LUA] Creare un cubo 3D

Prima di tutto vi dico che questa guida è fatta interamente da me e non l'ho presa da nessun forum/sito. Grazie a questa guida sarete in grado di fare in lua un Cubo che girerà a random e potrete scegliere il colore di ogni facciata, chissà se il creatore del CUBO DI RUBIK per psp ha usato questo metodo :shock: lol

Indice:
1. Colori
2. val, Colore sfondo e Scritta nel cubo
3. Il codice del cubo
4. Un altra parte del codice
5. Aggiungere scritte e funzioni

Iniziamo! :

1. Prima di tutto inseriamo i colori fondamentali e altri come grigio, ciano, ecc. che servono per i colori delle facciate del cubo, dello sfondo e delle scritte:

silver = Color.new(192,192,192)
red = Color.new(255,0,0)
red = Color.new(255, 0, 0)
green = Color.new(0, 255, 0)
blue = Color.new(0, 0, 255)
black = Color.new(0, 0, 0)
white = Color.new(255, 255, 255)
gray = Color.new(128, 128, 128)
cyan = Color.new(100, 255, 255)



Ovviamente voi potete aggiungerne altri oppure utilizzare quelli che volete durante il codice che vi detterò in seguito, vi spiego brevemente i codici dei colori come prenderli, se vedete bene tra le parentesi ci sono 3 numeri. Es: (255,0,0) questo è blu perchè andando alla tavolozza di Paint e scegliendo il colore a fianco ci sono 4 numeri, il 4° non vi serve in questo momento ma a volte si mette, per "sfumare" un pò il colore.
___________________________________________________________________________

2. Ora vi darò il codice dove ci sarà il val, l'immagine di sfondo che potete fare come volete ma io vi dò un colore "predefinito" da me un celeste sfumato col bianco ed infine delle scritte che potete mettere dentro il cubo. Attenzione: se sono troppo lunghe o troppe parole non ci cacciano nel cubo.

val = 0

logo = Image.createEmpty(128, 64)
logo:clear(gray)
logo:print(20, 20, "PROVA CUBO", black)

Ora vi spiego, il val non dovete cambiarlo assolutamente è da li che vi farà vedere le scritte sul cubo e il cubo, senza quello vedrete lo schermo celeste e bianco sneza niente, poi c'è come già detto prima lo sfondo del cubo, predefinito da me celeste sfumato col bianco cambiando quelle cifre potrete ottenere un risultato diverso, blu sfumato col rosso, rosso con l'arancione, ecc. Poi c'è logo:clear(gray) che dovrebbe "inbianchire" la parte dove ci sarà il cubo così da permettere di vedere il cubo, quello lasciatelo così, ed infine logo:print dove potrete "proiettare" nel cubo la scritta/e dove volete voi a sinistra, a destra, giu, su, ecc. vi ho messo una posizione predefinita in basso a destra, ma poi voi potete metterlo al centro a sinistra e da qualche altra parte, poi c'è la scritta messa da me PROVA CUBO che poi voi potete mettere quello che volete, "CIAO","FIGO XD","HOMEPAGE", ecc.(potete mettere anche minuscolo), ed infine il colore della scritta, potete mettere il nome del colore che sta all'inizio nel punto 1. tipo gray(grigio), black(nero), white(bianco), cyan(ciano, celeste chairo chiaro), ecc. Passiamo al punto 3
___________________________________________________________________________

3. Ora passiamo al codice del cubo, non completamente però, vi spiego qualche cosetta su questo codice che nemmeno io sò spiegare bene :P

cube = {
{0, 0, red, -1, -1, 1}, -- 0
{2, 0, red, -1, 1, 1}, -- 4
{2, 2, red, 1, 1, 1}, -- 5

{0, 0, red, -1, -1, 1}, -- 0
{2, 2, red, 1, 1, 1}, -- 5
{0, 2, red, 1, -1, 1}, -- 1

{0, 0, red, -1, -1, -1}, -- 3
{2, 0, red, 1, -1, -1}, -- 2
{2, 2, red, 1, 1, -1}, -- 6

{0, 0, red, -1, -1, -1}, -- 3
{2, 2, red, 1, 1, -1}, -- 6
{0, 2, red, -1, 1, -1}, -- 7

{0, 0, green, 1, -1, -1}, -- 0
{2, 0, green, 1, -1, 1}, -- 3
{2, 2, green, 1, 1, 1}, -- 7

{0, 0, green, 1, -1, -1}, -- 0
{2, 2, green, 1, 1, 1}, -- 7
{0, 2, green, 1, 1, -1}, -- 4

{0, 0, green, -1, -1, -1}, -- 0
{2, 0, green, -1, 1, -1}, -- 3
{2, 2, green, -1, 1, 1}, -- 7

{0, 0, green, -1, -1, -1}, -- 0
{2, 2, green, -1, 1, 1}, -- 7
{0, 2, green, -1, -1, 1}, -- 4

{0, 0, blue, -1, 1, -1}, -- 0
{2, 0, blue, 1, 1, -1}, -- 1
{2, 2, blue, 1, 1, 1}, -- 2

{0, 0, blue, -1, 1, -1}, -- 0
{2, 2, blue, 1, 1, 1}, -- 2
{0, 2, blue, -1, 1, 1}, -- 3

{0, 0, blue, -1, -1, -1}, -- 4
{2, 0, blue, -1, -1, 1}, -- 7
{2, 2, blue, 1, -1, 1}, -- 6

{0, 0, blue, -1, -1, -1}, -- 4
{2, 2, blue, 1, -1, 1}, -- 6
{0, 2, blue, 1, -1, -1}, -- 5
}

plane = {
{blue, -8, -3, 0},
{cyan, 8, 3, 0},
{blue, 8, -3, 0},
{cyan, 8, 3, 0},
{blue, -8, -3, 0},
{cyan, -8, 3, 0},
}

Da come vedete sembra non capirci niente essendo un pò lungo ma adesso vi spiego meglio. Le prime 2 cifre sono diverse per ogni parte di codice che inizia con { e finisce con } ci sono solo 2 numeri e sono 2 e 0 e servono per regolare il cubo ad ogni facciata, blue, green, red ecc. sono i colori che ptoete cambiare di ogni facciata e qui non c'è bisogno di rispiegare i colori, invece dovrei speigarvi a che servono quelle 3 cifre col meno e senza(sotto inteso +) senza quei numeri il cubo non esisterebbe, uno serve per la profondità, un altro per lo spessore e un altro per l'evidenza(cioè senza sarebbe invisbile, parzialmente visibile o visibile), molte spesso si usa solo al cifra 1 così da far sembrare il cubo "normale" ma se andate a mettere 0 il cubo si "sballerebbe" e non si vedrà bene, quindi quel codice lasciatelo così e se vedete sono uguali per ogni facciata, infine il codice dei colori che li non devo spiegarvi nulla e dovete lasciarlo così(PS: le scritte tipo --4, --6, ecc. potete eliminarle sono solo commenti non leggibile dalla psp ma servono solo per gli sviluppatori per capirne qualcosa ;)). Passiamo al penultimo punto, il 4.
___________________________________________________________________________

4. Beh quei non sò spiegarvi perfettamente il codice e se lo facessi sprecherei mezza giornata, quindi vi dò il codice e vi dico cosa c'è:

while true do
screen:clear()
Gu.start3d()

-- clear screen
Gu.clearDepth(0);
Gu.clear(Gu.COLOR_BUFFER_BIT+Gu.DEPTH_BUFFER_BIT)

-- setup projection and view matrices

Gum.matrixMode(Gu.PROJECTION)
Gum.loadIdentity()
Gum.perspective(75, 16/9, 0.5, 1000)

Gum.matrixMode(Gu.VIEW)
Gum.loadIdentity()

-- setup matrix for triangle
Gum.matrixMode(Gu.MODEL)
Gum.loadIdentity()
Gum.translate(0, 0, -3);

-- draw triangle without texture

Gu.disable(Gu.TEXTURE_2D)
Gum.drawArray(Gu.TRIANGLES, Gu.COLOR_8888+Gu.VERTEX_32BITF+Gu.TRANSFORM_3D, plane)

-- setup texture

Gu.enable(Gu.BLEND)
Gu.blendFunc(Gu.ADD, Gu.SRC_ALPHA, Gu.ONE_MINUS_SRC_ALPHA, 0, 0)
Gu.enable(Gu.TEXTURE_2D);
Gu.texImage(logo)
Gu.texFunc(Gu.TFX_MODULATE, Gu.TCC_RGBA)
Gu.texEnvColor(white)
Gu.texFilter(Gu.LINEAR, Gu.LINEAR)
Gu.texScale(1, 1)
Gu.texOffset(0, 0)
Gu.ambientColor(white)

-- setup matrix for cube

Gum.matrixMode(Gu.MODEL)
Gum.loadIdentity()
Gum.translate(0, 0, -3.5);
Gum.rotateXYZ(val * 0.79 * (Gu.PI/180), val * 0.98 * (Gu.PI/180.0), val * 1.32 * (Gu.PI/180.0))

-- draw cube

Gum.drawArray(Gu.TRIANGLES, Gu.TEXTURE_32BITF+Gu.COLOR_8888+Gu.VERTEX_32BITF+Gu.TRANSFORM_3D, cube)

Gu.end3d()

val = val + 1

if Controls.read():start() then
screen:clear()
break
end

All'interno del codice si iniza con un while e vicino un true do e lasciatelo così, Poi ci sono degli Array, una funzione Matrix e altre funzioni per refolare meglio il cubo. Passiamo alla 5 ed ultimo punto, dopo questo imbarazzante punto 4.
___________________________________________________________________________

5. Infine, finalmente, possiamo scrivere come un normale homebrew qualcosa e aggiungere funzioni, ed ecco un codice esempio:

screen:print(150,10,"PROVA CUBO",black)
pad = Controls.read()
if pad:start() then
System.Quit()

end
screen.waitVblankStart()
screen.flip()
end

screen:print chi non sà a che serve è un codice fondamentale, dove serve a "stampare", proprio dalla parola print, una scritta dal colore che volete voi e dalla posizione xy che voelte voi dello schermo, non superando la norma dello schermo della psp, se non ricordo male è 480, 272. Un esempio che vi ho fatto è screen:print(150,10,"PROVA CUBO",black) 150, 10 è la posizione del testo se cambiate i numeri potrete spostarlo a sinistra, a destra, in basso e in su, "Prova cubo" è la scritta che comparirà sullo schermo della PSP, black non sto qui a dirvi a che serve perchè ve l'ho detto abbondantemente al 1° punto e ovviamente potete cambiarlo nei vari colori che avete aggiunto voi o che vi ho messo io predefiniti. if pad:start then e sotto System.Quit() è un opzione che vi ho messo io come prova e servirà per uscire quando cliccate start potete cambiarlo in pad:square pad:triangle pad:ltrigger(o pad:l) pad:rtrigger(o pad:r) pad:circle pad:cross pad:select pad:up pad:down pad:right pad:left (non ne ricordo altri :P) e potete cambiare anche la funzione tipo attivare l'USB, la flash 0, flash 1, flash 2, flash 3, formattare la memory stick, avviare un UMD, ecc. Ma c'è jak che fa queste tipo di Guide dove spiega approfondendo.

Ecco il download: http://www.megaupload.com/?d=G28S1J5J

[C] Come fare un menu

Ho voluto fare una guida per un Menu in C dato che non si trova da nessuna parte, o al massimo trovate il menu in OSLib ma poi è difficile creare applicazioni con l'OSLib. Questo è il codice:

#include
#include
#include
#include
#include
#include

#define printf pspDebugScreenPrintf


PSP_MODULE_INFO("Menu in C", 0, 1, 0);
PSP_MAIN_THREAD_ATTR(PSP_THREAD_ATTR_USER);

SceCtrlData currentPad, lastPad;

int opzione = 1;
int giu = 1;
int su = 1;
int cerchio = 1;

void Menu_A()
{
opzione = 1;
giu = 1;
su = 1;

pspDebugScreenClear();
pspDebugScreenSetTextColor(0xFF0000);
printf("\n Menu in C\n\n\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" Seleziona un opzione:\n\n");
pspDebugScreenSetTextColor(0x0000FF);
printf(" -> tasto 1\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" -> tasto 2\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" -> Esci\n\n\n");
pspDebugScreenSetTextColor(0x00FF00);
printf(" Premi X per selezionare un opzione.");
}

void Menu_B()
{
opzione = 2;
giu = 2;
su = 2;

pspDebugScreenClear();
pspDebugScreenSetTextColor(0xFF0000);
printf("\n Menu in C\n\n\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" Seleziona un opzione:\n\n");
printf(" -> tasto 1\n");
pspDebugScreenSetTextColor(0x0000FF);
printf(" -> tasto 2\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" -> Esci\n\n\n");
pspDebugScreenSetTextColor(0x00FF00);
printf(" Premi X per selezionare un opzione.");
}

void Menu_C()
{
opzione = 3;
giu = 3;
su = 3;

pspDebugScreenClear();
pspDebugScreenSetTextColor(0xFF0000);
printf("\n Menu in C\n\n\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" Seleziona un opzione:\n\n");
printf(" -> tasto 1\n");
pspDebugScreenSetTextColor(0xFFFFFF);
printf(" -> tasto 2\n");
pspDebugScreenSetTextColor(0x0000FF);
printf(" -> Esci\n\n\n");
pspDebugScreenSetTextColor(0x00FF00);
printf(" Premi X per selezionare un opzione.");
}

void Option_A()
{
cerchio = 4;

pspDebugScreenClear();
pspDebugScreenSetTextColor(0x00FF00);
printf("\n Prova tasto 1\n");
pspDebugScreenSetTextColor(0x00FF00);
printf("\n\n Premi O per uscire");
sceKernelDelayThread(2*1000*1000);
}

void Option_B()
{
cerchio = 5;

pspDebugScreenClear();
pspDebugScreenInit();
pspDebugScreenSetTextColor(0xFFFFFF);
printf("Prova tasto 2");
pspDebugScreenSetTextColor(0x00FF00);
printf("\n\n\n Premi O per uscire");
sceKernelDelayThread(2*1000*1000);
}

void Option_C()
{
pspDebugScreenSetTextColor(0x00FF00);
printf("\n\n\n\n Esco...");
sceKernelDelayThread(2*1000*1000);
sceKernelExitGame();
}

int main()
{
sceCtrlReadBufferPositive(&lastPad, 1);

pspDebugScreenInit();
Menu_A();

while(1)
{

sceCtrlReadBufferPositive(¤tPad, 1);

if( currentPad.Buttons != lastPad.Buttons )
{
lastPad = currentPad;

if(currentPad.Buttons & PSP_CTRL_DOWN)
{
switch(giu)
{
case 1: Menu_B();
break;

case 2: Menu_C();
break;

case 3: Menu_A();
break;
}
}

if(currentPad.Buttons & PSP_CTRL_UP)
{
switch(su)
{
case 1: Menu_C();
break;

case 2: Menu_A();
break;

case 3: Menu_B();
break;
}
}
}

if(currentPad.Buttons & PSP_CTRL_CROSS)
{
switch(opzione)
{
case 1: Option_A();
break;

case 2: Option_B();
break;

case 3: Option_C();
break;

}
}
if(currentPad.Buttons & PSP_CTRL_CIRCLE)
{
switch(cerchio)
{
case 4: Menu_A();
break;

case 5: Menu_A();
break;

}
}
}
}

i primi #inlcude includono le librerie necessarie per il menu. Verso al fine potete scelgiere quale tasto usare, per esempio io ho utilizzato cerchio per uscire potete utilizzare triangolo (PSP_CTRL_TRIANGLE) e quindi potete modificare dentro switch(triangolo) e poi modifcarlo in tuti i menu che lo contengono e nell'int iniziale. Al massimo spiegherò tutto più tardi...

ecco il Makefile.mk

TARGET = menu
OBJS = main.o
PSP_EBOOT_TITLE = Menu in C

BUILD_PRX = 1
PSP_FW_VERSION = 401

CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS) -c

LIBS =
LDFLAGS =

EXTRA_TARGETS = EBOOT.PBP

PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak

TARGET indica il nome che di deve dare al PRX (es.: ciao e il prx si chiamerà ciao.prx)
OBJS indica gli oggetti inclusi in questo caso main.o ma potrebbe essere crt0.o
PSP_EBOOT_TITLE indica il nome del vostro homebrew (es.: Ciao Mondo)
BUILD_PRX significa quanti PRX dovranno sucire in compilazione...
PSP_FW_VERSION sta ad indicare da quale versione si può utilizzare l'homebrew...
LIBS sono le librerie aggiuntive
EXTRA_TARGETS è sempre incluso EBOOT.PBP se non lo metti ti uscirà solo il PRX

Aperto pubblicamente il mio blog!

Ho pensato di aprire un blog su argomenti come hack, exploit e programming ed eccolo qua! Aggiornerò spesso il mio blog con nuovi hack, exploit e programmazione come C e LUA ;)