static data_check_t data_check_mng(const unsigned char *buffer, const unsigned int buffer_size, file_recovery_t *file_recovery)
{
static const unsigned char mng_footer[4]= {'M','E','N','D'};
while(file_recovery->calculated_file_size + buffer_size/2 >= file_recovery->file_size &&
file_recovery->calculated_file_size + 8 < file_recovery->file_size + buffer_size/2)
{
const unsigned int i=file_recovery->calculated_file_size - file_recovery->file_size + buffer_size/2;
const struct png_chunk *chunk=(const struct png_chunk *)&buffer[i];
if(memcmp(&buffer[i+4], mng_footer, sizeof(mng_footer))==0)
{
file_recovery->calculated_file_size+=12 + be32(chunk->length);
return DC_STOP;
}
if( !((isupper(buffer[i+4]) || islower(buffer[i+4])) &&
(isupper(buffer[i+5]) || islower(buffer[i+5])) &&
(isupper(buffer[i+6]) || islower(buffer[i+6])) &&
(isupper(buffer[i+7]) || islower(buffer[i+7]))))
{
file_recovery->offset_error=file_recovery->calculated_file_size+7;
return DC_ERROR;
}
file_recovery->offset_ok=file_recovery->calculated_file_size+7;
file_recovery->calculated_file_size+=12 + be32(chunk->length);
}
return DC_CONTINUE;
}
static data_check_t data_check_png(const unsigned char *buffer, const unsigned int buffer_size, file_recovery_t *file_recovery)
{
while(file_recovery->calculated_file_size + buffer_size/2 >= file_recovery->file_size &&
file_recovery->calculated_file_size + 8 < file_recovery->file_size + buffer_size/2)
{
const unsigned int i=file_recovery->calculated_file_size - file_recovery->file_size + buffer_size/2;
const struct png_chunk *chunk=(const struct png_chunk *)&buffer[i];
if(memcmp(&buffer[i+4], "IEND", 4)==0)
{
file_recovery->calculated_file_size+=12 + be32(chunk->length);
return DC_STOP;
}
// PNG chunk code
// IDAT IHDR PLTE bKGD cHRM fRAc gAMA gIFg gIFt gIFx hIST iCCP
// iTXt oFFs pCAL pHYs sBIT sCAL sPLT sRGB sTER tEXt tRNS zTXt
if( !((isupper(buffer[i+4]) || islower(buffer[i+4])) &&
(isupper(buffer[i+5]) || islower(buffer[i+5])) &&
(isupper(buffer[i+6]) || islower(buffer[i+6])) &&
(isupper(buffer[i+7]) || islower(buffer[i+7]))))
{
file_recovery->offset_error=file_recovery->calculated_file_size+7;
return DC_ERROR;
}
file_recovery->offset_ok=file_recovery->calculated_file_size+7;
file_recovery->calculated_file_size+=12 + be32(chunk->length);
}
return DC_CONTINUE;
}
static int header_check_dpx(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
static const unsigned char ver10[8]= {'V', '1', '.', '0', 0x00, 0x00, 0x00, 0x00};
const struct header_dpx *dpx=(const struct header_dpx *)buffer;
if(memcmp(dpx->vers, ver10, sizeof(ver10))==0)
{
struct tm tm_time;
if(be32(dpx->file_size) < 19)
return 0;
memset(&tm_time, 0, sizeof(tm_time));
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_dpx.extension;
file_recovery_new->calculated_file_size=be32(dpx->file_size);
file_recovery_new->data_check=&data_check_size;
file_recovery_new->file_check=&file_check_size;
tm_time.tm_sec=(dpx->create_time[17]-'0')*10+(dpx->create_time[18]-'0'); /* seconds 0-59 */
tm_time.tm_min=(dpx->create_time[14]-'0')*10+(dpx->create_time[15]-'0'); /* minutes 0-59 */
tm_time.tm_hour=(dpx->create_time[11]-'0')*10+(dpx->create_time[12]-'0'); /* hours 0-23*/
tm_time.tm_mday=(dpx->create_time[8]-'0')*10+(dpx->create_time[9]-'0'); /* day of the month 1-31 */
tm_time.tm_mon=(dpx->create_time[5]-'0')*10+(dpx->create_time[6]-'0')-1; /* month 0-11 */
tm_time.tm_year=(dpx->create_time[0]-'0')*1000+(dpx->create_time[1]-'0')*100+
(dpx->create_time[2]-'0')*10+(dpx->create_time[3]-'0')-1900; /* year */
tm_time.tm_isdst = -1; /* unknown daylight saving time */
file_recovery_new->time=mktime(&tm_time);
return 1;
}
return 0;
}
static void decrypt_spkg(void)
{
u16 flags;
u16 type;
struct keylist *k;
flags = be16(pkg + 0x08);
type = be16(pkg + 0x0a);
hdr_len = be64(pkg + 0x10);
dec_size = be64(pkg + 0x18);
if (type != 3)
fail("no .spkg file");
k = keys_get(KEY_SPKG);
if (k == NULL)
fail("no key found");
if (sce_decrypt_header(pkg, k) < 0)
fail("header decryption failed");
meta_offset = be32(pkg + 0x0c);
n_sections = be32(pkg + meta_offset + 0x60 + 0xc);
if (n_sections != 3)
fail("invalid section count: %d", n_sections);
}
static data_check_t data_check_bac(const unsigned char *buffer, const unsigned int buffer_size, file_recovery_t *file_recovery)
{
if(buffer_size < 2*0x18)
{
file_recovery->data_check=NULL;
file_recovery->file_check=NULL;
return DC_CONTINUE;
}
while(file_recovery->calculated_file_size + buffer_size/2 >= file_recovery->file_size &&
file_recovery->calculated_file_size + 0x18 < file_recovery->file_size + buffer_size/2)
{
const unsigned int i=file_recovery->calculated_file_size - file_recovery->file_size + buffer_size/2;
const struct block_header *hdr=(const struct block_header *)&buffer[i];
const unsigned int block_size=be32(hdr->BlockSize);
#ifdef DEBUG_BACULA
const unsigned int block_nbr=be32(hdr->BlockNumber);
log_trace("file_bac.c: block %u size %u, calculated_file_size %llu\n",
block_nbr, block_size,
(long long unsigned)file_recovery->calculated_file_size);
#endif
if(memcmp(hdr->ID, "BB02", 4)!=0 || block_size<0x18)
{
log_error("file_bac.c: invalid block at %llu\n",
(long long unsigned)file_recovery->calculated_file_size);
return DC_STOP;
}
file_recovery->calculated_file_size+=(uint64_t)block_size;
}
#ifdef DEBUG_BACULA
log_trace("file_bac.c: new calculated_file_size %llu\n",
(long long unsigned)file_recovery->calculated_file_size);
#endif
return DC_CONTINUE;
}
static int header_check_ra(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
if(buffer[4]==0x00 && buffer[5]==0x03)
{ /* V3 */
const struct ra3_header *ra3=(const struct ra3_header *)buffer;
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_ra.extension;
file_recovery_new->calculated_file_size=8 + be16(ra3->header_size) + be32(ra3->data_size);
file_recovery_new->data_check=&data_check_size;
file_recovery_new->file_check=&file_check_size;
return 1;
}
else if(buffer[4]==0x00 && buffer[5]==0x04 &&
buffer[8]=='.' && buffer[9]=='r' && buffer[10]=='a' && buffer[11]=='4')
{ /* V4 */
const struct ra4_header *ra4=(const struct ra4_header *)buffer;
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_ra.extension;
file_recovery_new->calculated_file_size=40 + be16(ra4->header_size) + be32(ra4->data_size);
file_recovery_new->data_check=&data_check_size;
file_recovery_new->file_check=&file_check_size;
return 1;
}
return 0;
}
static void decompress_pkg(void *ptr)
{
u32 meta_offset;
u32 n_sections;
u32 i;
u64 offset;
u64 size;
int compressed;
u8 *tmp;
meta_offset = be32(pkg + 0x0c);
n_sections = be32(pkg + meta_offset + 0x60 + 0xc);
for (i = 0; i < n_sections; i++) {
tmp = pkg + meta_offset + 0x80 + 0x30 * i;
offset = be64(tmp);
size = be64(tmp + 8);
compressed = 0;
if (be32(tmp + 0x2c) == 0x2)
compressed = 1;
if (compressed) {
// XXX: is always only the last section compressed?
if (i + 1 != n_sections)
fail("weird pkg: not only last section is compressed");
decompress(pkg + offset, size,
ptr, dec_size);
}
}
}
void BRSHA256(void *md32, const void *data, size_t len)
{
size_t i;
uint32_t x[16], buf[] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
0x1f83d9ab, 0x5be0cd19 }; // initial buffer values
assert(md32 != NULL);
assert(data != NULL || len == 0);
for (i = 0; i < len; i += 64) { // process data in 64 byte blocks
memcpy(x, (const uint8_t *)data + i, (i + 64 < len) ? 64 : len - i);
if (i + 64 > len) break;
_BRSHA256Compress(buf, x);
}
memset((uint8_t *)x + (len - i), 0, 64 - (len - i)); // clear remainder of x
((uint8_t *)x)[len - i] = 0x80; // append padding
if (len - i >= 56) _BRSHA256Compress(buf, x), memset(x, 0, 64); // length goes to next block
x[14] = be32((uint32_t)(len >> 29)), x[15] = be32((uint32_t)(len << 3)); // append length in bits
_BRSHA256Compress(buf, x); // finalize
for (i = 0; i < 8; i++) buf[i] = be32(buf[i]); // endian swap
memcpy(md32, buf, 32); // write to md
mem_clean(x, sizeof(x));
mem_clean(buf, sizeof(buf));
}
static data_check_t data_check_flv(const unsigned char *buffer, const unsigned int buffer_size, file_recovery_t *file_recovery)
{
static uint32_t datasize=0;
while(file_recovery->calculated_file_size + buffer_size/2 >= file_recovery->file_size &&
file_recovery->calculated_file_size + 15 < file_recovery->file_size + buffer_size/2)
{
const unsigned int i=file_recovery->calculated_file_size - file_recovery->file_size + buffer_size/2;
const struct flv_tag *tag=(const struct flv_tag *)&buffer[i];
#ifdef DEBUG_FLV
log_info("cfs=0x%llx datasize=%u\n", (long long unsigned)file_recovery->calculated_file_size, datasize);
#endif
if((be32(tag->prev_tag_size)==0 && file_recovery->calculated_file_size < buffer_size/2) ||
be32(tag->prev_tag_size)==11+datasize)
{
datasize=(tag->data_size[0]<<16) | (tag->data_size[1]<<8) | tag->data_size[2];
if((tag->info&0xc0)!=0 || datasize==0
|| tag->streamID[0]!=0 || tag->streamID[1]!=0 || tag->streamID[2]!=0 )
{
file_recovery->calculated_file_size+=4;
return DC_STOP;
}
file_recovery->calculated_file_size+=4+11+datasize;
}
else
return DC_ERROR;
}
return DC_CONTINUE;
}
void parse_brlyt(char *filename)
{
FILE* fp = fopen(filename, "rb");
if(fp == NULL) {
printf("Error! Couldn't open %s!\n", filename);
exit(1);
}
fseek(fp, 0, SEEK_END);
size_t file_size = ftell(fp);
dbgprintf("Filesize is %d\n", file_size);
u8* brlyt_file = (u8*)malloc(file_size);
dbgprintf("brlyt_file allocated\n");
fseek(fp, 0, SEEK_SET);
fread(brlyt_file, file_size, 1, fp);
dbgprintf("brlyt_file read to.\n");
BRLYT_fileoffset = 0;
brlyt_header header;
BRLYT_ReadDataFromMemory(&header, brlyt_file, sizeof(brlyt_header));
BRLYT_CheckHeaderSanity(header, file_size);
brlyt_entry *entries;
BRLYT_fileoffset = be16(header.lyt_offset);
brlyt_entry_header tempentry;
int i;
dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size);
for(i = 0; BRLYT_fileoffset < file_size; i++) {
BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
BRLYT_fileoffset += be32(tempentry.length);
dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size);
}
int entrycount = i;
entries = (brlyt_entry*)calloc(entrycount, sizeof(brlyt_entry));
dbgprintf("%08x\n", entries);
if(entries == NULL) {
printf("Couldn't allocate for entries!\n");
exit(1);
}
BRLYT_fileoffset = be16(header.lyt_offset);
for(i = 0; i < entrycount; i++) {
dbgprintf("&(entries[i]) = %08x\n", &(entries[i]));
BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header));
memcpy(entries[i].magic, tempentry.magic, 4);
entries[i].length = tempentry.length;
entries[i].data_location = BRLYT_fileoffset + sizeof(brlyt_entry_header);
BRLYT_fileoffset += be32(tempentry.length);
}
// int entrycnt = BRLYT_ReadEntries(brlyt_file, file_size, header, entries);
dbgprintf("%08x\n", entries);
printf("Parsed BRLYT! Information:\n");
printf("Main header:\n");
printf(" Magic: %c%c%c%c\n", header.magic[0], header.magic[1], header.magic[2], header.magic[3]);
printf(" Unk1: %08x\n", be32(header.unk1));
printf(" Filesize: %lu\n", be32(header.filesize));
printf(" %s real file size!\n", be32(header.filesize) == file_size ? "Matches" : "Does not match");
printf(" Offset to lyt1: %04x\n", be16(header.lyt_offset));
printf(" Unk2: %04x\n", be16(header.unk2));
printf("\nBRLYT Entries:");
PrintBRLYTEntries(entries, entrycount, brlyt_file);
}
static void parse_pkg(void)
{
if (memcmp(pkg, "SCE", 3) == 0)
parse_pkg_sce();
else if (be32(pkg) == 1)
parse_pkg_1();
else
fail("unknown pkg type: %08x", be32(pkg));
}
void PrintBRLYTEntry_lyt1(brlyt_entry entry, u8* brlyt_file)
{
brlyt_lyt1_chunk data;
BRLYT_fileoffset = entry.data_location;
BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_lyt1_chunk));
printf(" Type: %c%c%c%c\n", entry.magic[0], entry.magic[1], entry.magic[2], entry.magic[3]);
printf(" unk1: %08x\n", be32(data.unk[0]));
printf(" unk2: %08x\n", be32(data.unk[1]));
printf(" unk3: %08x\n", be32(data.unk[2]));
}
void setup_context()
{
// setup stack pointer
_ctx.reg[1][0] = 0x3FFD0; _ctx.reg[1][1] = 0x0; _ctx.reg[1][2] = 0x0; _ctx.reg[1][3] = 0x0;
wbe32(_ctx.ls + 0x7060, 0x32000600);
TextureBlobHeader* header = (TextureBlobHeader*)src_data;
TextureBlobChunk* chunks = (TextureBlobChunk*)(header + 1);
wbe32(_ctx.ls + 0x3BE40, be16((u8*)&header->type));
wbe32(_ctx.ls + 0x3BE44, be16((u8*)&header->quality));
wbe32(_ctx.ls + 0x3BE48, (u32)src_data + be32((u8*)&chunks[0].offset));
wbe32(_ctx.ls + 0x3BE4C, be32((u8*)&chunks[0].compressed_size));
wbe32(_ctx.ls + 0x3BE50, (u32)dst_data);
wbe32(_ctx.ls + 0x3BE54, be32((u8*)&chunks[0].decompressed_size));
wbe32(_ctx.ls + 0x3BE58, be16((u8*)&chunks[0].num_batches));
wbe32(_ctx.ls + 0x3BE5C, be16((u8*)&header->width));
wbe32(_ctx.ls + 0x3BE60, be16((u8*)&header->height));
wbe32(_ctx.ls + 0x3BE64, be32((u8*)&header->unk_0x0C));
wbe32(_ctx.ls + 0x3BE68, be32((u8*)&header->unk_0x10));
wbe32(_ctx.ls + 0x3BE6C, be32((u8*)&header->unk_0x14));
wbe32(_ctx.ls + 0x3BE70, be32((u8*)&header->unk_0x18));
wbe32(_ctx.ls + 0x3BE74, be32((u8*)&header->unk_0x1C));
wbe32(_ctx.ls + 0x3BE78, be32((u8*)&header->unk_0x20));
wbe32(_ctx.ls + 0x3BE7C, 0);
wbe32(_ctx.ls + 0x3BE80, 0);
wbe32(_ctx.ls + 0x3BE84, 0);
wbe32(_ctx.ls + 0x3BE8C, 0);
}
int sce_remove_npdrm(u8 *ptr, struct keylist *klist)
{
u64 ctrl_offset;
u64 ctrl_size;
u32 block_type;
u32 block_size;
u32 license_type;
char content_id[0x31] = {'\0'};
struct rif *rif;
struct actdat *actdat;
u8 enc_const[0x10];
u8 dec_actdat[0x10];
struct key klicensee;
u64 i;
ctrl_offset = be64(ptr + 0x58);
ctrl_size = be64(ptr + 0x60);
for (i = 0; i < ctrl_size; ) {
block_type = be32(ptr + ctrl_offset + i);
block_size = be32(ptr + ctrl_offset + i + 0x4);
if (block_type == 3) {
license_type = be32(ptr + ctrl_offset + i + 0x18);
switch (license_type) {
case 1:
// cant decrypt network stuff
return -1;
case 2:
memcpy(content_id, ptr + ctrl_offset + i + 0x20, 0x30);
rif = rif_get(content_id);
if (rif == NULL) {
return -1;
}
aes128(klist->rif->key, rif->padding, rif->padding);
aes128_enc(klist->idps->key, klist->npdrm_const->key, enc_const);
actdat = actdat_get();
if (actdat == NULL) {
return -1;
}
aes128(enc_const, &actdat->keyTable[swap32(rif->actDatIndex)*0x10], dec_actdat);
aes128(dec_actdat, rif->key, klicensee.key);
sce_decrypt_npdrm(ptr, klist, &klicensee);
return 1;
case 3:
sce_decrypt_npdrm(ptr, klist, klist->free_klicensee);
return 1;
}
}
i += block_size;
}
return 0;
}
void WriteBRLANTagData(tag_data* data, u16 count, FILE* fp)
{
tag_data writedata;
int i;
for(i = 0; i < count; i++) {
writedata.part1 = be32(data[i].part1);
writedata.part2 = be32(data[i].part2);
writedata.part3 = be32(data[i].part3);
fwrite(&writedata, sizeof(tag_data), 1, fp);
}
}
static void read_self_header(u8* ptr, fileinfo* info)
{
info->flags = be16(ptr + 0x08);
info->meta_offset = be32(ptr + 0x0c);
info->header_len = be64(ptr + 0x10);
info->filesize = be64(ptr + 0x18);
info->info_offset = be64(ptr + 0x28);
info->app_type = be32(ptr + info->info_offset + 0x0c);
klist = self_load_keys(info);
}
static void read_self_header(void)
{
flags = be16(ptr + 0x08);
meta_offset = be32(ptr + 0x0c);
header_len = be64(ptr + 0x10);
filesize = be64(ptr + 0x18);
info_offset = be64(ptr + 0x28);
app_type = be32(ptr + info_offset + 0x0c);
klist = self_load_keys();
}
void BRLAN_CreateXMLTag(tag_header tagHeader, void* data, u32 offset)
{
BRLAN_fileoffset = offset;
BRLAN_ReadDataFromMemory(&tagHeader, data, sizeof(tag_header));
printf("\t\t<tag type=\"%c%c%c%c\">\n", tagHeader.magic[0], tagHeader.magic[1], tagHeader.magic[2], tagHeader.magic[3]);
tag_entryinfo tagEntryInfo;
u32 tagentrylocations[tagHeader.entry_count];
BRLAN_ReadDataFromMemory(&tagentrylocations, data, tagHeader.entry_count * sizeof(u32));
u32 i, j;
for ( i = 0; i < tagHeader.entry_count; i++)
{
BRLAN_fileoffset = offset + be32(tagentrylocations[i]);
BRLAN_ReadDataFromMemory(&tagEntryInfo, data, sizeof(tag_entryinfo));
if(short_swap_bytes(tagEntryInfo.type) < 16)
printf("\t\t\t<entry type=\"%s\">\n", tag_types_list[short_swap_bytes(tagEntryInfo.type)]);
else
printf("\t\t\t<entry type=\"%u\">\n", short_swap_bytes(tagEntryInfo.type));
for( j = 0; j < short_swap_bytes(tagEntryInfo.coord_count); j++)
{
if ( tagEntryInfo.unk1 == 0x2 )
{
tag_data tagData;
BRLAN_ReadDataFromMemory(&tagData, data, sizeof(tag_data));
u32 p1 = be32(tagData.part1);
u32 p2 = be32(tagData.part2);
u32 p3 = be32(tagData.part3);
printf("\t\t\t\t<triplet>\n");
printf("\t\t\t\t\t<frame>%.15f</frame>\n", *(f32*)(&p1));
printf("\t\t\t\t\t<value>%.15f</value>\n", *(f32*)(&p2));
printf("\t\t\t\t\t<blend>%.15f</blend>\n", *(f32*)(&p3));
printf("\t\t\t\t</triplet>\n");
} else {
tag_data2 tagData2;
BRLAN_ReadDataFromMemory(&tagData2, data, sizeof(tag_data2));
u32 p1 = be32(tagData2.part1);
u16 p2 = short_swap_bytes(tagData2.part2);
u16 p3 = short_swap_bytes(tagData2.padding);
printf("\t\t\t\t<pair>\n");
printf("\t\t\t\t\t<data1>%.15f</data1>\n", *(f32*)(&p1));
printf("\t\t\t\t\t<data2>%04x</data2>\n", p2);
printf("\t\t\t\t\t<padding>%04x</padding>\n", p3);
printf("\t\t\t\t</pair>\n");
}
}
printf("\t\t\t</entry>\n");
}
printf("\t\t</tag>\n");
}
static int header_check_xcf(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const struct xcf_header *hdr=(const struct xcf_header *)buffer;
if(hdr->zero!=0)
return 0;
if(be32(hdr->width)==0 || be32(hdr->heigth)==0)
return 0;
if(be32(hdr->base_type) > 2)
return 0;
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_xcf.extension;
return 1;
}
static int header_check_xpt(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const struct TypeLibHeader *xpt=(const struct TypeLibHeader*)buffer;
if(be32(xpt->file_length) < 65)
return 0;
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_xpt.extension;
file_recovery_new->min_filesize=65;
file_recovery_new->calculated_file_size=be32(xpt->file_length);
file_recovery_new->data_check=&data_check_size;
file_recovery_new->file_check=&file_check_size;
return 1;
}
void WriteBRLANHeader(brlan_header rlanhead, FILE* fp)
{
brlan_header writehead;
writehead.magic[0] = rlanhead.magic[0];
writehead.magic[1] = rlanhead.magic[1];
writehead.magic[2] = rlanhead.magic[2];
writehead.magic[3] = rlanhead.magic[3];
writehead.unk1 = be32(rlanhead.unk1);
writehead.file_size = be32(rlanhead.file_size);
writehead.pai1_offset = short_swap_bytes(rlanhead.pai1_offset);
writehead.pai1_count = short_swap_bytes(rlanhead.pai1_count);
fwrite(&writehead, sizeof(brlan_header), 1, fp);
}
static void read_section(u32 i, struct self_sec *sec)
{
u8 *ptr;
ptr = self + sec_offset + i*0x20;
sec->idx = i;
sec->offset = be64(ptr + 0x00);
sec->size = be64(ptr + 0x08);
sec->compressed = be32(ptr + 0x10) == 2 ? 1 : 0;
sec->encrypted = be32(ptr + 0x20);
sec->next = be64(ptr + 0x20);
}
static int header_check_prc(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const struct DatabaseHdrType_s *prc=(const struct DatabaseHdrType_s *)buffer;
if(memcmp(&buffer[0x30],prc_header,sizeof(prc_header))==0 &&
be32(prc->uniqueIDSeed)==0)
{
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_prc.extension;
file_recovery_new->time=be32(prc->modificationDate);
return 1;
}
return 0;
}
u16 BRLAN_ReadAnimations(BRLAN_animation **anims)
{
BRLAN_fileoffset = 0;
brlan_header header;
BRLAN_ReadDataFromMemoryX(&header, BRLAN_file, sizeof(brlan_header));
BRLAN_fileoffset = be16(header.pai1_offset);
brlan_pai1_universal universal;
BRLAN_ReadDataFromMemoryX(&universal, BRLAN_file, sizeof(brlan_pai1_universal));
int pai1_header_type;
brlan_pai1_header_type1 pai1_header1;
brlan_pai1_header_type2 pai1_header2;
brlan_pai1_header_type2 pai1_header;
if((be32(universal.flags) & (1 << 25)) >= 1) {
pai1_header_type = 2;
BRLAN_ReadDataFromMemory(&pai1_header2, BRLAN_file, sizeof(brlan_pai1_header_type2));
} else {
pai1_header_type = 1;
BRLAN_ReadDataFromMemory(&pai1_header1, BRLAN_file, sizeof(brlan_pai1_header_type1));
}
CreateGlobal_pai1(&pai1_header, pai1_header1, pai1_header2, pai1_header_type);
int tagcount = be16(pai1_header.num_entries);
u32 *taglocations = (u32*)calloc(tagcount, sizeof(u32));
*anims = (BRLAN_animation*)calloc(tagcount, sizeof(BRLAN_animation));
fourcc CCs[256];
memset(CCs, 0, 256*4);
BRLAN_fileoffset = be32(pai1_header.entry_offset) + be16(header.pai1_offset);
BRLAN_ReadDataFromMemory(taglocations, BRLAN_file, tagcount * sizeof(u32));
int animcnt = 1;
int i;
for(i = 0; i < tagcount; i++) {
BRLAN_fileoffset = be32(taglocations[i]) + be16(header.pai1_offset);
brlan_entry tmpentry;
BRLAN_ReadDataFromMemory(&tmpentry, BRLAN_file, sizeof(brlan_entry));
if((be32(tmpentry.flags) & (1 << 25)) >= 1)
BRLAN_fileoffset += sizeof(u32);
memcpy(anims[animcnt]->name, tmpentry.name, 20);
fourcc magick;
BRLAN_ReadDataFromMemoryX(magick, BRLAN_file, 4);
memcpy(CCs[i], magick, 4);
if(FourCCInList(CCs[i]) == 1) {
anims[animcnt]->offset = BRLAN_fileoffset;
ReadTagFromBRLAN(anims, animcnt);
animcnt++;
}
}
return tagcount;
}
static int header_check_qcow2(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const QCowHeader2_t *header=(const QCowHeader2_t*)buffer;
uint64_t min_size=be64(header->backing_file_offset);
if(min_size < be64(header->l1_table_offset))
min_size=be64(header->l1_table_offset);
else if(min_size < be64(header->refcount_table_offset))
min_size=be64(header->refcount_table_offset);
else if(min_size < be64(header->snapshots_offset))
min_size=be64(header->snapshots_offset);
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_cow.extension;
file_recovery_new->min_filesize=min_size;
#ifdef DEBUG_COW
log_info("magic %lu\n", be32(header->magic));
log_info("version %lu\n", be32(header->version));
log_info("backing_file_offset %llu\n", be64(header->backing_file_offset));
log_info("backing_file_size %lu\n", be32(header->backing_file_size));
log_info("cluster_bits %lu\n", be32(header->cluster_bits));
log_info("size %llu\n", be64(header->size)); /* in bytes */
log_info("crypt_method %lu\n", be32(header->crypt_method));
log_info("l1_size %lu\n", be32(header->l1_size)); /* XXX: save number of clusters instead ? */
log_info("l1_table_offset %llu\n", be64(header->l1_table_offset));
log_info("refcount_table_offset %llu\n", be64(header->refcount_table_offset));
log_info("refcount_table_clusters %lu\n", be32(header->refcount_table_clusters));
log_info("nb_snapshots %lu\n", be32(header->nb_snapshots));
log_info("snapshots_offset %llu\n", be64(header->snapshots_offset));
#endif
return 1;
}
int gecko_readmem()
{
u8 startaddress[4];
u8 endaddress[5];
u8 ack_packet = 0xAA;
u8 pcresponse;
static u8 packetbuffer[packetsize] ATTRIBUTE_ALIGN(32);
u32 memstart;
u32 memend;
u32 memrange;
u32 fullpackets;
u32 currentpacket;
u32 lastpacketbytes;
// ACK
usb_sendbuffer_safe(gecko_channel,&ack_packet,1);
usb_recvbuffer_safe(gecko_channel,&startaddress,4);
usb_recvbuffer_safe(gecko_channel,&endaddress,4);
memstart = be32(startaddress);
memend = be32(endaddress);
memrange = memend - memstart;
fullpackets = memrange / packetsize;
lastpacketbytes = memrange % packetsize;
// Full Packet Size
for (currentpacket = 0;currentpacket < fullpackets;)
{
memcpy(packetbuffer, (char*)memstart, packetsize);
usb_sendbuffer(gecko_channel,&packetbuffer, packetsize);
usb_recvbuffer_safe(gecko_channel,&pcresponse,1);
if(pcresponse != 0xAA){
// printf("failed to read packet\n");
return 0;
}
memstart += packetsize;
currentpacket++;
}
// Remainder
if(lastpacketbytes > 0) {
memcpy(packetbuffer, (char*)memstart, lastpacketbytes);
usb_sendbuffer_safe(gecko_channel,&packetbuffer, lastpacketbytes);
usb_recvbuffer_safe(gecko_channel,&pcresponse,1);
}
// printf("memory dump complete\n");
return 1;
}
static int header_check_xfs_sb(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const struct xfs_sb *sb=(const struct xfs_sb *)buffer;
if(sb->sb_magicnum!=be32(XFS_SB_MAGIC) ||
(uint16_t)be16(sb->sb_sectsize) != (1U << sb->sb_sectlog) ||
(uint32_t)be32(sb->sb_blocksize) != (1U << sb->sb_blocklog) ||
(uint16_t)be16(sb->sb_inodesize) != (1U << sb->sb_inodelog))
return 0;
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_xfs.extension;
file_recovery_new->calculated_file_size=be32(sb->sb_blocksize);
file_recovery_new->data_check=&data_check_size;
file_recovery_new->file_check=&file_check_size;
return 1;
}
static int test_Linux_SWAP(const union swap_header *swap_header, partition_t *partition)
{
if(memcmp(swap_header->magic.magic,"SWAP-SPACE",10)==0)
{
partition->upart_type=UP_LINSWAP;
return 0;
}
if(memcmp(swap_header->magic.magic,"SWAPSPACE2",10)==0)
{
partition->upart_type=UP_LINSWAP2;
return 0;
}
if(memcmp(swap_header->magic8k.magic,"SWAP-SPACE",10)==0)
{
partition->upart_type=UP_LINSWAP_8K;
return 0;
}
if(memcmp(swap_header->magic8k.magic,"SWAPSPACE2",10)==0)
{
if(le32(swap_header->info.version) <= be32(swap_header->info.version))
partition->upart_type=UP_LINSWAP2_8K;
else
partition->upart_type=UP_LINSWAP2_8KBE;
return 0;
}
return 1;
}
static int header_check_flv(const unsigned char *buffer, const unsigned int buffer_size, const unsigned int safe_header_only, const file_recovery_t *file_recovery, file_recovery_t *file_recovery_new)
{
const struct flv_header *flv=(const struct flv_header *)buffer;
if((flv->type_flags & 0xfa)==0 && be32(flv->data_offset)>=9)
{
reset_file_recovery(file_recovery_new);
file_recovery_new->extension=file_hint_flv.extension;
if(file_recovery_new->blocksize < 15)
return 1;
file_recovery_new->calculated_file_size=be32(flv->data_offset);
file_recovery_new->data_check=&data_check_flv;
file_recovery_new->file_check=&file_check_size;
return 1;
}
return 0;
}
static void _BRSHA256Compress(uint32_t *r, uint32_t *x)
{
static const uint32_t k[] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
int i;
uint32_t a = r[0], b = r[1], c = r[2], d = r[3], e = r[4], f = r[5], g = r[6], h = r[7], t1, t2, w[64];
for (i = 0; i < 16; i++) w[i] = be32(x[i]);
for (; i < 64; i++) w[i] = s3(w[i - 2]) + w[i - 7] + s2(w[i - 15]) + w[i - 16];
for (i = 0; i < 64; i++) {
t1 = h + s1(e) + ch(e, f, g) + k[i] + w[i];
t2 = s0(a) + maj(a, b, c);
h = g, g = f, f = e, e = d + t1, d = c, c = b, b = a, a = t1 + t2;
}
r[0] += a, r[1] += b, r[2] += c, r[3] += d, r[4] += e, r[5] += f, r[6] += g, r[7] += h;
var_clean(&a, &b, &c, &d, &e, &f, &g, &h, &t1, &t2);
mem_clean(w, sizeof(w));
}
