void init_Self_Ehdr(Self_Ehdr* hdr) {
set_u64(&(hdr->e_magic), 3);
#ifdef NPDRM
set_u64(&(hdr->e_cfsize), sizeof(Self_Cflags)+sizeof(Self_NPDRM));
#else
set_u64(&(hdr->e_cfsize), sizeof(Self_Cflags));
#endif
}
int main(int argc, char* argv[]) {
u8* data;
u8 sha_key[0x40];
if(argc < 2) {
printf("usage: %s my.pkg\n", argv[0]);
return -1;
}
int i;
FILE *f=fopen(argv[1], "rb");
fseek(f, 0, SEEK_END);
int nlen = ftell(f);
fseek(f, 0, SEEK_SET);
data = (u8*)malloc(nlen);
fread(data, 1, nlen, f);
fclose(f);
pkg_header *header = (pkg_header *)data;
int data_offset = get_u64(&(header->dataOffset));
int data_size = get_u64(&(header->dataSize));
// decrypt debug
u8 sha_crap[0x40];
memset(sha_crap, 0, 0x40);
memcpy(sha_crap, &data[0x60], 8);
memcpy(sha_crap+0x8, &data[0x60], 8);
memcpy(sha_crap+0x10, &data[0x68], 8);
memcpy(sha_crap+0x18, &data[0x68], 8);
int dptr;
for(dptr = data_offset; dptr < (data_offset+data_size); dptr+=0x10) {
u8 hash[0x14];
SHA1(sha_crap, 0x40, hash);
for(i=0; i<0x10; i++) data[dptr+i] ^= hash[i];
set_u64(sha_crap+0x38, get_u64(sha_crap+0x38)+1);
}
// recrypt retail
u8 pkg_key[0x10];
memcpy(pkg_key, &data[0x70], 0x10);
AES_KEY aes_key;
AES_set_encrypt_key(retail_pkg_aes_key, 128, &aes_key);
int num=0;
u8 ecount_buf[0x10];
memset(ecount_buf, 0, 0x10);
AES_ctr128_encrypt(&data[data_offset], &data[data_offset], data_size, &aes_key, pkg_key, ecount_buf, &num);
// write back
FILE *g = fopen(argv[1], "wb");
data[4] = 0x80; // set finalize flag
memset(&data[(data_offset+data_size)], 0, 0x60);
// add hash
SHA1(data, nlen-0x20, &data[nlen-0x20]);
fwrite(data, 1, nlen, g);
fclose(g);
}
void init_Self_Ihdr(Self_Ihdr* hdr) {
#ifdef NPDRM
set_u64(&(hdr->i_authid), 0x1010000001000003LL);
set_u32(&(hdr->i_apptype), 8);
#else
#ifdef SPRX
set_u64(&(hdr->i_authid), 0x1070000052000001LL);
#else
//set_u64(&(hdr->i_authid), 0x10700003FD000001LL);
set_u64(&(hdr->i_authid), 0x10700003FF000001LL);
#endif
set_u32(&(hdr->i_apptype), 4);
#endif
//set_u64(&(hdr->i_authid), 0x1070000500000001LL);
set_u32(&(hdr->i_magic), 0x01000002);
set_u64(&(hdr->i_version), 0x0003005500000000LL);
//set_u64(&(hdr->i_version), 0x0003004000000000LL);
//set_u64(&(hdr->i_version), 0x0003000000000000LL);
//set_u64(&(hdr->i_version), 0x0001004000001000LL);
//set_u64(&(hdr->i_version), 0x0001000000000000LL);
}
int main(int argc, char* argv[]) {
int i;
u8 ecount_buf[0x10], iv[0x10];
size_t countp;
int num;
Self_Segment* segment_ptr;
memset(zero_padding, 0, sizeof(zero_padding));
#ifdef NPDRM
if(argc < 3) {
printf("usage: %s input.elf output.self <titleid>\n", argv[0]);
printf(" warning NPDRM cares about the output file name, do not rename\n");
return -1;
}
#else
if(argc < 2) {
printf("usage: %s input.elf output.self\n", argv[0]);
return -1;
}
#endif
// init randomness
gmp_randinit_default(r_state);
gmp_randseed_ui(r_state, time(NULL));
// read elf file
read_elf_file(argv[1]);
input_elf_header = (Elf64_Ehdr*)input_elf_data;
printf("ELF header size @ %x\n", get_u16(&(input_elf_header->e_ehsize)) );
printf("%d program headers @ %llx\n", get_u16(&(input_elf_header->e_phnum)), get_u64(&(input_elf_header->e_phoff)));
printf("%d section headers @ %llx\n", get_u16(&(input_elf_header->e_shnum)), get_u64(&(input_elf_header->e_shoff)));
// loop through the segments
enumerate_segments();
printf("segments enumerated\n");
// setup self headers
Self_Shdr output_self_header; memset(&output_self_header, 0, sizeof(output_self_header));
Self_Ehdr output_extended_self_header; memset(&output_extended_self_header, 0, sizeof(output_extended_self_header));
Self_Ihdr output_self_info_header; memset(&output_self_info_header, 0, sizeof(output_self_info_header));
init_Self_Shdr(&output_self_header);
init_Self_Ehdr(&output_extended_self_header);
init_Self_Ihdr(&output_self_info_header);
set_u64(&output_self_header.s_exsize, input_elf_len);
// setup segment header
segment_certification_header segment_header; memset(&segment_header, 0, sizeof(segment_header));
set_u32(&(segment_header.version), 1);
// NPDRM
#ifdef NPDRM
Self_NPDRM npdrm; memset(&npdrm, 0, sizeof(npdrm));
init_Self_NPDRM(&npdrm, argv[3], argv[2]);
#endif
// useless bullshit
Self_SDKversion sdkversion;
Self_Cflags cflags;
memcpy(&sdkversion, sdkversion_static, sizeof(Self_SDKversion));
memcpy(&cflags, cflags_static, sizeof(Self_Cflags));
// generate metadata encryption keys
metadata_crypt_header md_header; memset(&md_header, 0, sizeof(md_header));
#ifdef NPDRM
memcpy(&md_header, npdrm_keypair_d, sizeof(md_header));
#else
mpz_t bigriv, bigerk;
mpz_init(bigriv); mpz_init(bigerk);
mpz_urandomb(bigerk, r_state, 128);
mpz_urandomb(bigriv, r_state, 128);
mpz_export(md_header.erk, &countp, 1, 0x10, 1, 0, bigerk);
mpz_export(md_header.riv, &countp, 1, 0x10, 1, 0, bigriv);
#endif
// init signing shit
mpz_t n,k,da,kinv,r,cs,z;
mpz_init(n); mpz_init(k); mpz_init(da); mpz_init(r); mpz_init(cs); mpz_init(z); mpz_init(kinv);
mpz_import(r, 0x14, 1, 1, 0, 0, KEY(R));
mpz_import(n, 0x14, 1, 1, 0, 0, KEY(n));
mpz_import(k, 0x14, 1, 1, 0, 0, KEY(K));
mpz_import(da, 0x14, 1, 1, 0, 0, KEY(Da));
mpz_invert(kinv, k, n);
segment_certification_sign all_signed; memset(&all_signed, 0, sizeof(all_signed));
mpz_export(all_signed.R, &countp, 1, 0x14, 1, 0, r);
// **** everything here is still length independent ***
build_segment_crypt_data();
set_u32(&(segment_header.crypt_len), (segment_crypt_data_len)/0x10);
set_u32(&(segment_header.unknown2), 0x30); // needed??
printf("built crypt data\n");
// start building metadata in theory, ordering is fixed now
memset(&start_file, 0, sizeof(file_ll));
running_size = 0;
// 0x000 -- Self_Shdr
add_file_section(&output_self_header, sizeof(output_self_header));
// 0x020 -- Self_Ehdr
add_file_section(&output_extended_self_header, sizeof(output_extended_self_header));
// 0x070 -- Self_Ihdr
set_u64(&(output_extended_self_header.e_ihoff), running_size);
add_file_section(&output_self_info_header, sizeof(output_self_info_header));
// 0x090 -- elf data
set_u64(&(output_extended_self_header.e_ehoff), running_size);
set_u64(&(output_extended_self_header.e_phoff), running_size+get_u64(&(input_elf_header->e_phoff)));
add_file_section(input_elf_data, get_u64(&(input_elf_header->e_phoff)) + get_u16(&(input_elf_header->e_phnum)) * sizeof(Elf64_Phdr));
add_file_section(zero_padding, (0x10-(running_size&0xF))&0xF);
// 0x*** -- all Self_PMhdr(including not in crypt)
set_u64(&(output_extended_self_header.e_pmoff), running_size);
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
add_file_section(&(segment_ptr->pmhdr), sizeof(segment_ptr->pmhdr));
segment_ptr = segment_ptr->next_segment;
}
// 0x*** -- Self_SDKversion
set_u64(&(output_extended_self_header.e_svoff), running_size);
add_file_section(&sdkversion, sizeof(sdkversion));
// 0x*** -- ???
#ifdef NPDRM
add_file_section(zero_padding, 0x20);
#endif
// 0x*** -- Self_Cflags
set_u64(&(output_extended_self_header.e_cfoff), running_size);
add_file_section(&cflags, sizeof(cflags));
#ifdef NPDRM
// 0x*** -- npdrm data
add_file_section(&npdrm, sizeof(npdrm));
#endif
// 0x*** -- metadata_crypt_header
set_u32(&(output_self_header.s_esize), running_size - sizeof(output_self_header));
add_file_section(&md_header, sizeof(md_header));
// 0x*** -- segment_certification_header
add_file_section(&segment_header, sizeof(segment_header));
// 0x*** -- all segment_certification_segment incrypt
int incrypt_count = 0;
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
if(segment_ptr->incrypt) {
add_file_section(&(segment_ptr->enc_segment), sizeof(segment_ptr->enc_segment));
incrypt_count++;
}
segment_ptr = segment_ptr->next_segment;
}
set_u32(&(segment_header.segment_count), incrypt_count);
// 0x*** -- segment_crypt_data
add_file_section(segment_crypt_data, segment_crypt_data_len);
// 0x*** -- nubpadding_static
add_file_section(nubpadding_static, sizeof(nubpadding_static));
// 0x*** -- segment_certification_sign
set_u64(&(segment_header.signature_offset), running_size);
add_file_section(&all_signed, sizeof(all_signed));
// 0x*** -- data must be 0x80 aligned
if((running_size%0x80) != 0) {
add_file_section(zero_padding, 0x80-(running_size%0x80));
}
// 0x*** -- data
set_u64(&(output_self_header.s_shsize), running_size);
// ...data...
segment_ptr = &first_segment;
while(segment_ptr != NULL) {
set_u64(&(segment_ptr->enc_segment.segment_offset), running_size);
set_u64(&(segment_ptr->pmhdr.pm_offset), running_size);
add_file_section(segment_ptr->data, segment_ptr->len);
add_file_section(zero_padding, segment_ptr->padding);
segment_ptr = segment_ptr->next_segment;
}
// 0x*** -- section table
#ifndef SPRX
set_u64(&(output_extended_self_header.e_shoff), running_size);
add_file_section(input_elf_data+get_u64(&(input_elf_header->e_shoff)), get_u16(&(input_elf_header->e_shnum)) * sizeof(Elf64_Shdr));
#endif
// ***DONE***
printf("file built\n");
// write self file in memory <-- useful comment
write_self_file_in_memory();
printf("self written in memory\n");
// sign shit
u8 digest[0x14];
SHA1(output_self_data, get_u64(&(segment_header.signature_offset)), digest);
mpz_import(z, 0x14, 1, 1, 0, 0, digest);
mpz_mul(cs, r, da); mpz_mod(cs, cs, n);
mpz_add(cs, cs, z); mpz_mod(cs, cs, n);
mpz_mul(cs, cs, kinv); mpz_mod(cs, cs, n);
//mpz_export(all_signed.S, &countp, 1, 0x14, 1, 0, cs);
mpz_export(&output_self_data[get_u64(&output_self_data[get_u32(output_self_data+0xC)+0x60])+0x16], &countp, 1, 0x14, 1, 0, cs);
// write the output self test
FILE *test_self_file = fopen("test_out", "wb");
fwrite(output_self_data, 1, running_size, test_self_file);
fclose(test_self_file);
// encrypt metadata
int metadata_offset = get_u32(&(output_self_header.s_esize)) + sizeof(Self_Shdr);
#ifndef NO_CRYPT
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(&output_self_data[metadata_offset], 128, &aes_key);
memcpy(iv, &output_self_data[metadata_offset+0x20], 16);
AES_ctr128_encrypt(&output_self_data[0x40+metadata_offset], &output_self_data[0x40+metadata_offset], get_u64(&(output_self_header.s_shsize))-metadata_offset-0x40, &aes_key, iv, ecount_buf, &num);
printf("encrypted metadata\n");
#ifdef NPDRM
memcpy(&output_self_data[metadata_offset], npdrm_keypair_e, sizeof(md_header));
#else
AES_set_encrypt_key(KEY(erk), 256, &aes_key);
memcpy(iv, KEY(riv), 16);
AES_cbc_encrypt(&output_self_data[metadata_offset], &output_self_data[metadata_offset], 0x40, &aes_key, iv, AES_ENCRYPT);
printf("encrypted keys\n");
#endif
#else
printf("NO_CRYPT is enabled...self is broken\n");
#endif
// write the output self
FILE *output_self_file = fopen(argv[2], "wb");
fwrite(output_self_data, 1, running_size, output_self_file);
fclose(output_self_file);
}
void enumerate_segments() {
int i,num;
size_t countp;
u8 ecount_buf[0x10],iv[0x10];
Self_Segment* segment_ptr = &first_segment;
Elf64_Phdr* elf_segment = (Elf64_Phdr*)(&input_elf_data[get_u64(&(input_elf_header->e_phoff))]);
mpz_t riv, erk, hmac;
mpz_init(riv); mpz_init(erk); mpz_init(hmac);
for(i=0;i<get_u16(&(input_elf_header->e_phnum));i++) {
memset(segment_ptr, 0, sizeof(Self_Segment));
// these are choices you can make
/*segment_ptr->compressed = (i<2);
segment_ptr->incrypt = (i<6); // **TESTING
segment_ptr->encrypted = (i<5);*/
#ifdef NPDRM
segment_ptr->encrypted = (i<5);
segment_ptr->compressed = (i<4);
segment_ptr->incrypt = (i<7);
#else
segment_ptr->encrypted = 1;
segment_ptr->compressed = 1;
segment_ptr->incrypt = 1;
#endif
set_u32(&(segment_ptr->enc_segment.segment_number), i);
set_u32(&(segment_ptr->enc_segment.unknown2), 2);
set_u32(&(segment_ptr->enc_segment.unknown3), 3);
mpz_urandomb(hmac, r_state, 512);
mpz_export(segment_ptr->crypt_segment.hmac, &countp, 1, 0x40, 1, 0, hmac);
if(segment_ptr->encrypted) {
mpz_urandomb(erk, r_state, 128);
mpz_urandomb(riv, r_state, 128);
mpz_export(segment_ptr->crypt_segment.erk, &countp, 1, 0x10, 1, 0, erk);
mpz_export(segment_ptr->crypt_segment.riv, &countp, 1, 0x10, 1, 0, riv);
}
segment_ptr->rlen = get_u64(&(elf_segment->p_filesz));
u32 in_data_offset = get_u64(&(elf_segment->p_offset));
u8* in_data = &input_elf_data[in_data_offset];
if(segment_ptr->compressed) {
int def_size = DEFLATION_BUFFER_SIZE;
printf("deflated...", def(in_data, segment_ptr->rlen, def_buffer, &def_size)); fflush(stdout);
segment_ptr->len = def_size;
segment_ptr->data = (u8*)malloc(segment_ptr->len);
memcpy(segment_ptr->data, def_buffer, def_size);
} else {
segment_ptr->len = segment_ptr->rlen;
segment_ptr->data = (u8*)malloc(segment_ptr->len);
memcpy(segment_ptr->data, in_data, segment_ptr->len);
}
/*if(i==0) {
segment_ptr->padding = 0x26A4;
} else if(i==1) {
segment_ptr->padding = 0xC;
} else {
segment_ptr->padding = 0;
}*/
segment_ptr->padding = (0x10-(segment_ptr->len&0xF))&0xF;
// hacks to make it match
/*if(segment_ptr->len == 0x14BCC8) {
segment_ptr->padding += 0x4330;
}*/
printf("processing segment %d with rlen %x len %x offset %x...", i, segment_ptr->rlen, segment_ptr->len, in_data_offset); fflush(stdout);
//hexdump((u8*)elf_segment, sizeof(Elf64_Phdr));
set_u64(&(segment_ptr->enc_segment.segment_size), segment_ptr->len);
set_u32(&(segment_ptr->enc_segment.segment_crypt_flag), 1+segment_ptr->encrypted);
set_u32(&(segment_ptr->enc_segment.segment_compressed_flag), 1+segment_ptr->compressed);
set_u64(&(segment_ptr->pmhdr.pm_size), segment_ptr->len);
set_u32(&(segment_ptr->pmhdr.pm_compressed), 1+segment_ptr->compressed);
set_u32(&(segment_ptr->pmhdr.pm_encrypted), segment_ptr->encrypted);
// compute sha1
SHA_CTX c;
SHA1_ghetto_init(&c, segment_ptr->crypt_segment.hmac);
SHA1_Update(&c, segment_ptr->data, segment_ptr->len);
SHA1_ghetto_final(segment_ptr->crypt_segment.sha1, &c, segment_ptr->crypt_segment.hmac);
if(segment_ptr->encrypted) {
printf("encrypted..."); fflush(stdout);
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(segment_ptr->crypt_segment.erk, 128, &aes_key);
memcpy(iv, segment_ptr->crypt_segment.riv, 16);
#ifndef NO_CRYPT
AES_ctr128_encrypt(segment_ptr->data, segment_ptr->data, segment_ptr->len, &aes_key, iv, ecount_buf, &num);
#endif
}
if(i != get_u16(&(input_elf_header->e_phnum))-1) {
segment_ptr->next_segment = malloc(sizeof(Self_Segment));
}
elf_segment += 1; // 1 is sizeof(Elf64_Phdr)
segment_ptr = segment_ptr->next_segment;
printf("\n");
}
}
int main(int argc, char* argv[]) {
int i;
u8 ecount_buf[0x10], iv[0x10];
size_t countp;
int num;
if(argc < 4) {
printf("usage: %s input.elf output.self keytype keysuffix\n", argv[0]);
return -1;
}
Elf64_Ehdr input_elf_header;
FILE *input_elf_file = fopen(argv[1], "rb");
fseek(input_elf_file, 0, SEEK_END);
int nlen = ftell(input_elf_file);
fseek(input_elf_file, 0, SEEK_SET);
input_elf_data = (u8*)malloc(nlen);
fread(input_elf_data, 1, nlen, input_elf_file);
fclose(input_elf_file);
memcpy(&input_elf_header, input_elf_data, sizeof(input_elf_header));
FILE *output_self_file = fopen(argv[2], "wb");
printf("ELF header size @ %x\n", get_u16(&(input_elf_header.e_ehsize)) );
printf("%d program headers @ %64llX\n", get_u16(&(input_elf_header.e_phnum)), get_u64(&(input_elf_header.e_phoff)));
printf("%d section headers @ %64llX\n", get_u16(&(input_elf_header.e_shnum)), get_u64(&(input_elf_header.e_shoff)));
Self_Shdr output_self_header; memset(&output_self_header, 0, sizeof(output_self_header));
Self_Ehdr output_extended_self_header; memset(&output_extended_self_header, 0, sizeof(output_extended_self_header));
Self_Ihdr output_self_info_header; memset(&output_self_info_header, 0, sizeof(output_self_info_header));
set_u32(&(output_self_header.s_magic), 0x53434500);
set_u32(&(output_self_header.s_hdrversion), 2);
set_u16(&(output_self_header.s_flags), 1);
set_u16(&(output_self_header.s_hdrtype), 1);
// header size and file size aren't known yet
set_u64(&(output_extended_self_header.e_magic), 3);
set_u64(&(output_extended_self_header.e_ihoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr));
set_u64(&(output_extended_self_header.e_ehoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr)+sizeof(Self_Ihdr));
set_u64(&(output_extended_self_header.e_phoff), sizeof(Self_Shdr)+sizeof(Self_Ehdr)+sizeof(Self_Ihdr)+get_u64(&(input_elf_header.e_phoff)));
// section header offset unknown
set_u64(&(output_self_info_header.i_authid), 0x1070000500000001LL);
set_u32(&(output_self_info_header.i_magic), 0x01000002);
set_u32(&(output_self_info_header.i_apptype), 4);
set_u64(&(output_self_info_header.i_version), 0x0003000000000000LL);
// set static data
int phnum = get_u16(&(input_elf_header.e_phnum));
u32 phsize = (sizeof(Elf64_Phdr)*get_u16(&(input_elf_header.e_phnum)));
Self_SDKversion sdkversion;
Self_Cflags cflags;
memcpy(&sdkversion, sdkversion_static, sizeof(Self_SDKversion));
memcpy(&cflags, cflags_static, sizeof(Self_Cflags));
int running_size = (sizeof(output_self_header)+sizeof(output_extended_self_header)+sizeof(output_self_info_header)+sizeof(input_elf_header)+phsize+0xF)&0xFFFFFFF0;
set_u64(&(output_extended_self_header.e_pmoff), running_size); running_size += phnum*sizeof(Self_PMhdr);
set_u64(&(output_extended_self_header.e_svoff), running_size); running_size += sizeof(Self_SDKversion);
set_u64(&(output_extended_self_header.e_cfoff), running_size); running_size += sizeof(Self_Cflags);
set_u64(&(output_extended_self_header.e_cfsize), sizeof(Self_Cflags));
set_u32(&(output_self_header.s_esize), running_size - sizeof(output_self_header));
printf("running size is %X\n", running_size);
int maxsection = 6;
running_size += sizeof(metadata_crypt_header)+sizeof(segment_certification_header)+maxsection*(sizeof(segment_certification_segment)+sizeof(segment_certification_crypt_encrypted))+sizeof(segment_certification_sign)+sizeof(nubpadding_static);
printf("running size is %X\n", running_size);
set_u64(&(output_self_header.s_shsize), running_size);
// init randomness
gmp_randstate_t r_state;
gmp_randinit_default(r_state);
gmp_randseed_ui(r_state, time(NULL));
// loop through the sections
segment_certification_header segment_header; memset(&segment_header, 0, sizeof(segment_header));
Self_Section first_section;
Self_Section* section_ptr = &first_section;
set_u64(&(segment_header.signature_offset), running_size-sizeof(segment_certification_sign));
set_u32(&(segment_header.unknown1), 1);
set_u32(&(segment_header.segment_count), phnum);
set_u32(&(segment_header.crypt_len), (phnum*sizeof(segment_certification_crypt_encrypted))/0x10);
Elf64_Phdr* elf_segment = (Elf64_Phdr*)(&input_elf_data[get_u64(&(input_elf_header.e_phoff))]);
for(i=0;i<phnum;i++) {
memset(section_ptr, 0, sizeof(Self_Section));
//set_u64(&(section_ptr->enc_segment.segment_offset), get_u64(&(elf_segment->p_vaddr)));
set_u64(&(section_ptr->enc_segment.segment_offset), running_size);
set_u64(&(section_ptr->enc_segment.segment_size), get_u64(&(elf_segment->p_filesz)));
set_u32(&(section_ptr->enc_segment.segment_crypt_flag), 2);
set_u32(&(section_ptr->enc_segment.segment_sha1_index), i*8);
set_u32(&(section_ptr->enc_segment.segment_erk_index), i*8+6);
set_u32(&(section_ptr->enc_segment.segment_riv_index), i*8+7);
set_u32(&(section_ptr->enc_segment.segment_number), i);
set_u32(&(section_ptr->enc_segment.unknown2), 2);
set_u32(&(section_ptr->enc_segment.unknown3), 3);
set_u32(&(section_ptr->enc_segment.unknown4), 2);
set_u64(&(section_ptr->pmhdr.pm_offset), running_size);
set_u64(&(section_ptr->pmhdr.pm_size), get_u64(&(elf_segment->p_filesz)));
set_u32(&(section_ptr->pmhdr.pm_compressed), 1);
set_u32(&(section_ptr->pmhdr.pm_encrypted), 1);
mpz_t riv, erk, hmac;
mpz_init(riv); mpz_init(erk); mpz_init(hmac);
mpz_urandomb(erk, r_state, 128);
mpz_urandomb(riv, r_state, 128);
mpz_urandomb(hmac, r_state, 512);
mpz_export(section_ptr->crypt_segment.erk, &countp, 1, 0x10, 1, 0, erk);
mpz_export(section_ptr->crypt_segment.riv, &countp, 1, 0x10, 1, 0, riv);
mpz_export(section_ptr->crypt_segment.hmac, &countp, 1, 0x40, 1, 0, hmac);
section_ptr->rlen = get_u64(&(elf_segment->p_filesz));
section_ptr->len = ((section_ptr->rlen)+0xF)&0xFFFFFFF0;
section_ptr->data = (u8*)malloc(section_ptr->len);
u32 in_data_offset = get_u64(&(elf_segment->p_offset)); // + get_u16(&(input_elf_header.e_ehsize)) + (sizeof(Elf64_Phdr)*get_u16(&(input_elf_header.e_phnum)));
u8* in_data = &input_elf_data[in_data_offset];
printf("processing segment %d with len %x offset %x\n", i, section_ptr->len, in_data_offset);
//hexdump((u8*)elf_segment, sizeof(Elf64_Phdr));
/*SHA_CTX c;
SHA1_ghetto_init(&c, section_ptr->crypt_segment.hmac);
SHA1_Update(&c, in_data, section_ptr->rlen);
SHA1_ghetto_final(section_ptr->crypt_segment.sha1, &c, section_ptr->crypt_segment.hmac);*/
sha1_hmac(section_ptr->crypt_segment.hmac, in_data, section_ptr->rlen, section_ptr->crypt_segment.sha1);
memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(section_ptr->crypt_segment.erk, 128, &aes_key);
memcpy(iv, section_ptr->crypt_segment.riv, 16);
#ifdef NO_CRYPT
memcpy(section_ptr->data, in_data, section_ptr->len);
#else
//AES_ctr128_encrypt(in_data, section_ptr->data, section_ptr->len, &aes_key, iv, ecount_buf, &num);
aes128ctr((u8*)&aes_key, iv, in_data, section_ptr->len, section_ptr->data);
#endif
running_size += section_ptr->len;
// next
if(i != phnum-1) {
section_ptr->next_section = malloc(sizeof(Self_Section));
}
elf_segment += 1; // 1 is sizeof(Elf64_Phdr)
section_ptr = section_ptr->next_section;
}
printf("segment processing done\n");
// section table offset
set_u64(&(output_extended_self_header.e_shoff), running_size);
// lay out the metadata
u8 metadata[0x2000]; memset(metadata, 0, 0x2000);
u32 metadata_len = 0;
memcpy(&metadata[metadata_len], &output_self_header, sizeof(output_self_header)); metadata_len += sizeof(output_self_header);
memcpy(&metadata[metadata_len], &output_extended_self_header, sizeof(output_extended_self_header)); metadata_len += sizeof(output_extended_self_header);
memcpy(&metadata[metadata_len], &output_self_info_header, sizeof(output_self_info_header)); metadata_len += sizeof(output_self_info_header);
memcpy(&metadata[metadata_len], &input_elf_header, sizeof(input_elf_header)); metadata_len += sizeof(input_elf_header);
memcpy(&metadata[metadata_len], &input_elf_data[get_u64(&(input_elf_header.e_phoff))], phsize); metadata_len += phsize;
metadata_len = (metadata_len+0xF)&0xFFFFFFF0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->pmhdr), sizeof(section_ptr->pmhdr)); metadata_len += sizeof(section_ptr->pmhdr);
section_ptr = section_ptr->next_section;
}
memcpy(&metadata[metadata_len], &sdkversion, sizeof(sdkversion)); metadata_len += sizeof(sdkversion);
memcpy(&metadata[metadata_len], &cflags, sizeof(cflags)); metadata_len += sizeof(cflags);
printf("top half of metadata ready\n");
// generate metadata encryption keys
mpz_t bigriv, bigerk;
mpz_init(bigriv); mpz_init(bigerk);
mpz_urandomb(bigerk, r_state, 128);
mpz_urandomb(bigriv, r_state, 128);
metadata_crypt_header md_header;
mpz_export(md_header.erk, &countp, 1, 0x10, 1, 0, bigerk);
mpz_export(md_header.riv, &countp, 1, 0x10, 1, 0, bigriv);
memcpy(&metadata[metadata_len], &md_header, sizeof(md_header)); metadata_len += sizeof(md_header);
memcpy(&metadata[metadata_len], &segment_header, sizeof(segment_header)); metadata_len += sizeof(segment_header);
// copy section data
int csection;
csection = 0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->enc_segment), sizeof(section_ptr->enc_segment)); metadata_len += sizeof(section_ptr->enc_segment);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
csection = 0;
section_ptr = &first_section;
while(section_ptr != NULL) {
memcpy(&metadata[metadata_len], &(section_ptr->crypt_segment), sizeof(section_ptr->crypt_segment)); metadata_len += sizeof(section_ptr->crypt_segment);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
// nubpadding time
memcpy(&metadata[metadata_len], nubpadding_static, sizeof(nubpadding_static)); metadata_len += sizeof(nubpadding_static);
// sign shit
u8 digest[0x14];
sha1(metadata, metadata_len, digest);
printf("metadata len is %X\n", metadata_len);
//hexdump(metadata, metadata_len);
//hexdump_nl(digest, 0x14);
segment_certification_sign all_signed;
memset(&all_signed, 0, sizeof(all_signed));
#ifdef GEOHOT_SIGN
mpz_t n,k,da,kinv,r,cs,z;
mpz_init(n); mpz_init(k); mpz_init(da); mpz_init(r); mpz_init(cs); mpz_init(z); mpz_init(kinv);
mpz_import(r, 0x14, 1, 1, 0, 0, appold_R);
mpz_import(n, 0x14, 1, 1, 0, 0, appold_n);
mpz_import(k, 0x14, 1, 1, 0, 0, appold_K);
mpz_import(da, 0x14, 1, 1, 0, 0, appold_Da);
mpz_invert(kinv, k, n);
mpz_import(z, 0x14, 1, 1, 0, 0, digest);
mpz_mul(cs, r, da); mpz_mod(cs, cs, n);
mpz_add(cs, cs, z); mpz_mod(cs, cs, n);
mpz_mul(cs, cs, kinv); mpz_mod(cs, cs, n);
mpz_export(all_signed.R, &countp, 1, 0x14, 1, 0, r);
mpz_export(all_signed.S, &countp, 1, 0x14, 1, 0, cs);
#else
get_keys(argv[3], argv[4]);
//ecdsa_set_curve(appnew_ctype);
//ecdsa_set_pub(appnew_pub);
//ecdsa_set_priv(appnew_priv);
//ecdsa_sign(digest, all_signed.R, all_signed.S);
#endif
memcpy(&metadata[metadata_len], &all_signed, sizeof(all_signed)); metadata_len += sizeof(all_signed);
// encrypt metadata
int metadata_offset = get_u32(&(output_self_header.s_esize)) + sizeof(Self_Shdr);
#ifndef NO_CRYPT
/*memset(ecount_buf, 0, 16); num=0;
AES_set_encrypt_key(&metadata[metadata_offset], 128, &aes_key);
memcpy(iv, &metadata[metadata_offset+0x20], 16);
//AES_ctr128_encrypt(&metadata[0x40+metadata_offset], &metadata[0x40+metadata_offset], metadata_len-metadata_offset-0x40, &aes_key, iv, ecount_buf, &num);
aes128ctr(&metadata[0x20+metadata_offset], &metadata[0x40+metadata_offset], &metadata[0x60+metadata_offset], metadata_len-metadata_offset-0x60, &metadata[0x60+metadata_offset]);
printf("encrypted metadata\n");
//AES_set_encrypt_key(appold_erk, 256, &aes_key);
//memcpy(iv, appold_riv, 16);
AES_set_encrypt_key(appnew_erk, 256, &aes_key);
memcpy(iv, appnew_riv, 16);
//AES_cbc_encrypt(&metadata[metadata_offset], &metadata[metadata_offset], 0x40, &aes_key, iv, AES_ENCRYPT);
aes256cbc_enc(appnew_erk, appnew_riv, &metadata[metadata_offset], 0x40, &metadata[metadata_offset]);
printf("encrypted keys\n");*/
//k.key = appnew_erk;
//k.iv = appnew_riv;
sce_encrypt_header(metadata, &ks);
#endif
// write the output self
fwrite(metadata, 1, metadata_len, output_self_file);
csection = 0;
section_ptr = &first_section;
while(section_ptr != 0) {
printf("writing section with size %X\n", section_ptr->len);
fwrite(section_ptr->data, 1, section_ptr->len, output_self_file);
section_ptr = section_ptr->next_section;
if((++csection) == maxsection) break;
}
fwrite(&input_elf_data[get_u64(&(input_elf_header.e_shoff))], sizeof(Elf64_Shdr), get_u16(&(input_elf_header.e_shnum)), output_self_file);
fclose(output_self_file);
}
