// trust - 0
// crash - 1
int confirm_usage_right(void)
{
u8 shabuf[20];
u8 psid[16];
int i;
memset(psid, 0, sizeof(psid));
_sceOpenPSIDGetOpenPSID = (void*)sctrlHENFindFunction("sceOpenPSID_Service", "sceOpenPSID_driver", 0xC69BEBCE);
(*_sceOpenPSIDGetOpenPSID)(psid);
printk("Dumping PSID:\n");
printk( "%02X%02X%02X%02X"
"%02X%02X%02X%02X"
"%02X%02X%02X%02X"
"%02X%02X%02X%02X\n", psid[0], psid[1], psid[2], psid[3], psid[4], psid[5], psid[6], psid[7], psid[8], psid[9], psid[10], psid[11], psid[12], psid[13], psid[14], psid[15]);
memset(shabuf, 0, sizeof(shabuf));
sceKernelUtilsSha1Digest(psid, sizeof(psid), shabuf);
for(i=0; i<512-1; ++i) {
sceKernelUtilsSha1Digest(shabuf, sizeof(shabuf), shabuf);
}
return !is_trusted_user(shabuf);
}
unsigned int libsNameToNid(const char *name)
{
u8 digest[20];
unsigned int nid;
if(sceKernelUtilsSha1Digest((u8 *) name, strlen(name), digest) >= 0)
{
nid = digest[0] | (digest[1] << 8) | (digest[2] << 16) | (digest[3] << 24);
return nid;
}
return 0;
}
static int lua_sha1sum(lua_State *L)
{
size_t size;
const char *string = luaL_checklstring(L, 1, &size);
if (!string) return luaL_error(L, "System.sha1sum() takes a string as argument.");
u8 digest[16];
sceKernelUtilsSha1Digest((u8*)string, size, digest);
int i;
char result[33];
for (i = 0; i < 16; i++) sprintf(result + 2 * i, "%02x", digest[i]);
lua_pushstring(L, result);
return 1;
}
void checkSha1() {
const int random_data_len = strlen(random_data);
sceKernelUtilsSha1BlockInit(&sha1ctx);
sceKernelUtilsSha1BlockUpdate(&sha1ctx, random_data, 16);
sceKernelUtilsSha1BlockUpdate(&sha1ctx, random_data + 16, random_data_len - 16);
struct Sha1Digest digest;
sceKernelUtilsSha1BlockResult(&sha1ctx, &digest);
// Probably not the right byte order.
printf("Sha1 in parts: %08x%08x%08x%08x%08x\n", digest.data[0], digest.data[1], digest.data[2], digest.data[3], digest.data[4]);
memset(&digest, 0, sizeof(digest));
sceKernelUtilsSha1Digest(random_data, random_data_len, &digest);
printf("Sha1 digest: %08x%08x%08x%08x%08x\n", digest.data[0], digest.data[1], digest.data[2], digest.data[3], digest.data[4]);
}
int makeCxmbThemeFile( unsigned int cxmb_magic, const char * cxmb_theme_file )
{
const char * folders_name[] = {
"/data/cert",
"/dic",
"/font",
"/kd",
"/kd/resource",
"/vsh/etc",
"/vsh/module",
"/vsh/resource"
};
int folders_count = 8;
const char * support_exts[] = {
".prx",
".rco",
".bmp",
".pmf",
".res",
".pgf",
".bwfon",
".rsc",
".dat",
".img",
".bin",
".cet",
".dic"
};
int exts_count = 13;
int dfd, heap_id, fd, i, bytes, file_count = 0;
unsigned int ptf_h[5];
char path[128], file[128], preview[64];
u8 * buf;
// dectect if theme file in conf exist
int ctf = sceIoOpen( cxmb_theme_file, PSP_O_RDONLY, 0644 );
if ( ctf >= 0 )
{
log( "theme file exist!\n" );
sceIoClose( ctf );
return 0;
}
dfd = sceIoDopen( "ms0:/cxmb" );
if ( dfd < 0 )
{
log( "no cxmb folder found!\n" );
return 0;
}
sceIoDclose( dfd );
sprintf( preview, "ms0:/cxmb%s", &cxmb_theme_file[14] );
preview[strlen( preview ) - 3] = 'p';
log( "preview: %s\n", preview );
fd = sceIoOpen( preview, PSP_O_RDONLY, 0644 );
if ( fd < 0 )
{
log( "no preview ptf file found!\n" );
return 0;
}
sceIoLseek( fd, 0x100, PSP_SEEK_SET );
sceIoRead( fd, ptf_h, 20 );
// create CXMB_MKCTF_BUF_SIZE + 32kb heap
heap_id = sceKernelCreateHeap( 2, CXMB_MKCTF_BUF_SIZE + 1024 * 32 , 1, "cxmb_tmp_heap");
if ( heap_id < 0 )
{
log( "failed in create heap in making cxmb theme file!\n" );
return -1;
}
CtfHeader * ch = ( CtfHeader * )sceKernelAllocHeapMemory( heap_id, sizeof( CtfHeader ) * 64 );
memset( ch, 0, sizeof( CtfHeader ) * 64 );
SceIoDirent * ent = ( SceIoDirent * )sceKernelAllocHeapMemory( heap_id, sizeof( SceIoDirent ) );
memset( ent, 0, sizeof( SceIoDirent ) );
sceIoMkdir( "ms0:/PSP/THEME", 0777 );
ctf = sceIoOpen( cxmb_theme_file, PSP_O_RDWR | PSP_O_CREAT | PSP_O_TRUNC, 0777 );
if ( ctf < 0 )
{
log( "failed in opening %s\n", cxmb_theme_file );
sceKernelFreeHeapMemory( heap_id, ent );
sceKernelFreeHeapMemory( heap_id, ch );
sceKernelDeleteHeap( heap_id );
return -1;
}
else
{
if ( ptf_h[2] == 0 )
ptf_h[2] = sceIoLseek( fd, 0, PSP_SEEK_END );
log( "ptf sections size %08x\n", ptf_h[2] );
buf = sceKernelAllocHeapMemory( heap_id, ptf_h[2] );
if ( buf )
{
sceIoLseek( fd, 0, PSP_SEEK_SET );
sceIoRead( fd, buf, ptf_h[2] );
sceIoWrite( ctf, buf, ptf_h[2] );
sceIoClose( fd );
sceKernelFreeHeapMemory( heap_id, buf );
sceIoLseek( ctf, 0x10, PSP_SEEK_SET );
sceIoWrite( ctf, &cxmb_magic, 4 );
sceIoLseek( ctf, 0x1C, PSP_SEEK_SET );
sceIoWrite( ctf, &ptf_h[2], 4 );
memset( &ptf_h[2], 0, 12 );
sceIoLseek( ctf, 0x100, PSP_SEEK_SET );
sceIoWrite( ctf, ptf_h, 20 );
sceIoLseek( ctf, 0, PSP_SEEK_END );
for ( i = 0; i < folders_count; i ++ )
{
sprintf( path, "ms0:/cxmb%s", folders_name[i] );
dfd = sceIoDopen( path );
if ( dfd < 0 )
{
log( "folder %s not found!\n", path );
continue;
}
log( "parsing %s\n", path );
while ( sceIoDread( dfd, ent ) > 0 )
{
log( "found %s\n", ent->d_name );
if ( ( ent->d_stat.st_attr & FIO_SO_IFDIR ) || ent->d_name[0] == '.' )
{
log( "ignore %s\n", ent->d_name );
continue;
}
if ( endwithistrs( ent->d_name, support_exts, exts_count ) )
{
sprintf( file, "%s/%s", path, ent->d_name );
sprintf( ch[file_count].name, "%s/%s", folders_name[i], ent->d_name );
ch[file_count].start = sceIoLseek( ctf, 0, PSP_SEEK_CUR );
ch[file_count].size = 0;
if ( cmpistrs( ent->d_name, diff_files, diff_count ) )
{
char ori_file[128];
sprintf( ori_file, "%s/%s", CXMB_SUPPORT_FOLDER, ent->d_name );
ch[file_count].size = makeDiff( file, ori_file, heap_id, ctf );
}
else
{
log( "dealing with %s\n", ent->d_name );
fd = sceIoOpen( file, PSP_O_RDONLY, 0644 );
if ( fd < 0 )
{
log( "failed in opening %s\n", file );
continue;
}
buf = ( u8 * )sceKernelAllocHeapMemory( heap_id, CXMB_MKCTF_BUF_SIZE );
bytes = sceIoRead( fd, buf, CXMB_MKCTF_BUF_SIZE );
while( bytes > 0 )
{
ch[file_count].size += sceIoWrite( ctf, buf, bytes );
bytes = sceIoRead( fd, buf, CXMB_MKCTF_BUF_SIZE );
}
sceKernelFreeHeapMemory( heap_id, buf );
sceIoClose( fd );
}
if ( ch[file_count].size > 0 && ch[file_count].size < CXMB_MAX_FILE_SIZE )
{
log( "start: %08x size: %08x\n", ch[file_count].start, ch[file_count].size );
file_count ++;
}
}
else
{
log( "ignore %s\n", ent->d_name );
}
}
sceIoDclose( dfd );
}
}
else
{
log( "failed in allocating %08x heap\n", ptf_h[2] );
}
}
log( "file_count: %d\n", file_count );
if ( file_count > 0 )
{
u8 sha1[20];
sceKernelUtilsSha1Digest( ( u8 * )ch, sizeof( CtfHeader ) * file_count, sha1 );
sceIoWrite( ctf, ch, sizeof( CtfHeader ) * file_count );
sceIoLseek( ctf, 0x14, PSP_SEEK_SET );
sceIoWrite( ctf, &sha1[0], 4 );
sceIoWrite( ctf, &file_count, 4 );
sceIoClose( ctf );
}
else
{
sceIoClose( ctf );
sceIoRemove( cxmb_theme_file );
}
sceKernelFreeHeapMemory( heap_id, ent );
sceKernelFreeHeapMemory( heap_id, ch );
sceKernelDeleteHeap( heap_id );
return 0;
}
u32 get_address_id(u8 *address, u32 size) {
u32 digest[5];
sceKernelUtilsSha1Digest(address, size, (u8 *)&digest);
kprintf("current loaded mib id: %08X\n", *digest);
return *digest;
}
