// 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; }