DarkStore-3DS/Project_CTR
1
0
Fork 0
mirror of https://github.com/DarkStore-3DS/Project_CTR.git synced 2026-07-03 00:39:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c2a18c961d7094e0cf831dc5188850090c678f6a
Project_CTR/ncsd.c
T
3DSGuy c2a18c961d makerom v0.7
2014-04-21 18:44:00 +08:00

634 lines
20 KiB
C
Raw Blame History

#include "lib.h"
#include "ncch.h"
#include "exheader.h"
#include "ncsd.h"
#include "cia.h"
#include "tmd.h"
// Private Prototypes
/* RSA Crypto */
int SignCCI(u8 *Signature, u8 *NCSD_HDR);
int CheckCCISignature(u8 *Signature, u8 *NCSD_HDR);
/* cci_settings tools */
void init_CCISettings(cci_settings *set);
int get_CCISettings(cci_settings *cciset, user_settings *usrset);
void free_CCISettings(cci_settings *set);
/* CCI Data Gen/Write */
int BuildNCSDHeader(cci_settings *cciset, user_settings *usrset);
int BuildCardInfoHeader(cci_settings *cciset, user_settings *usrset);
int WriteCCI_HDR_ToFile(cci_settings *cciset);
int WriteCCI_Content_ToFile(cci_settings *cciset,user_settings *usrset);
int WriteCCI_DummyBytes(cci_settings *cciset);
/* Get Data from Content Files */
int CheckContent0(cci_settings *cciset, user_settings *usrset);
int GetDataFromContent0(cci_settings *cciset, user_settings *usrset);
int GetContentFP(cci_settings *cciset, user_settings *usrset);
/* Get Data from YAML Settings */
int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml);
int GetMediaSize(cci_settings *cciset, user_settings *usrset);
u64 GetUnusedSize(u64 MediaSize, u8 CardType);
int GetWriteableAddress(cci_settings *cciset, user_settings *usrset);
int GetCardInfoBitmask(cci_settings *cciset, user_settings *usrset);
int CheckMediaSize(cci_settings *cciset);
static InternalCCI_Context ctx;
// Code
int build_CCI(user_settings *usrset)
{
int result = 0;
// Init Settings
cci_settings *cciset = calloc(1,sizeof(cci_settings));
if(!cciset) {
fprintf(stderr,"[CCI ERROR] Not enough memory\n");
return MEM_ERROR;
}
init_CCISettings(cciset);
// Get Settings
result = get_CCISettings(cciset,usrset);
if(result) goto finish;
// Create Output File
cciset->out = fopen(usrset->common.outFileName,"wb");
if(!cciset->out){
fprintf(stderr,"[CCI ERROR] Failed to create '%s'\n",usrset->common.outFileName);
result = FAILED_TO_CREATE_OUTFILE;
goto finish;
}
// Generate NCSD Header and Additional Header
result = BuildNCSDHeader(cciset,usrset);
if(result)
goto finish;
BuildCardInfoHeader(cciset,usrset);
// Write to File
WriteCCI_HDR_ToFile(cciset);
result = WriteCCI_Content_ToFile(cciset,usrset);
if(result)
goto finish;
// Fill out file if necessary
if(cciset->fillOutCci)
WriteCCI_DummyBytes(cciset);
// Close output file
finish:
if(result != FAILED_TO_CREATE_OUTFILE && cciset->out) fclose(cciset->out);
free_CCISettings(cciset);
return result;
}
int SignCCI(u8 *Signature, u8 *NCSD_HDR)
{
return ctr_sig(NCSD_HDR,sizeof(cci_hdr),Signature,ctx.keys->rsa.cciCfaPub,ctx.keys->rsa.cciCfaPvt,RSA_2048_SHA256,CTR_RSA_SIGN);
}
int CheckCCISignature(u8 *Signature, u8 *NCSD_HDR)
{
return ctr_sig(NCSD_HDR,sizeof(cci_hdr),Signature,ctx.keys->rsa.cciCfaPub,NULL,RSA_2048_SHA256,CTR_RSA_VERIFY);
}
void init_CCISettings(cci_settings *set)
{
memset(set,0,sizeof(cci_settings));
memset(&ctx,0,sizeof(InternalCCI_Context));
}
int get_CCISettings(cci_settings *cciset, user_settings *usrset)
{
ctx.keys = &usrset->common.keys;
int result = 0;
/* Importing Data from Content */
result = CheckContent0(cciset,usrset);
if(result) return result;
result = GetDataFromContent0(cciset,usrset);
if(result) return result;
result = GetContentFP(cciset,usrset);
if(result) return result;
/* Getting Data from YAML */
result = GetNCSDFlags(cciset,&usrset->common.rsfSet);
if(result) return result;
result = GetMediaSize(cciset,usrset);
if(result) return result;
result = CheckMediaSize(cciset);
if(result) return result;
/** Card Info Header Data **/
result = GetWriteableAddress(cciset,usrset);
if(result) return result;
result = GetCardInfoBitmask(cciset,usrset);
if(result) return result;
result = ImportCverDetails(cciset,usrset);
if(result) return result;
/* All Done */
return 0;
}
void free_CCISettings(cci_settings *set)
{
if(set->content){
for(int i = 1; i < 8; i++) {
if(set->content[i]) fclose(set->content[i]);
}
free(set->content);
}
free(set);
}
int BuildNCSDHeader(cci_settings *cciset, user_settings *usrset)
{
memcpy((u8*)ctx.cciHdr.magic,"NCSD",4);
u32_to_u8((u8*)ctx.cciHdr.mediaSize,(cciset->mediaSize/cciset->mediaUnit),LE);
memcpy((u8*)ctx.cciHdr.titleId,cciset->mediaId,8);
for(int i = 0; i < 8; i++){
u32_to_u8((u8*)ctx.cciHdr.offset_sizeTable[i].offset,(cciset->contentOffset[i]/cciset->mediaUnit),LE);
u32_to_u8((u8*)ctx.cciHdr.offset_sizeTable[i].size,(cciset->contentSize[i]/cciset->mediaUnit),LE);
memcpy((u8*)ctx.cciHdr.partitionIdTable[i],cciset->contentTitleId[i],8);
}
memcpy((u8*)ctx.cciHdr.partitionFlags,cciset->flags,8);
if(SignCCI(ctx.signature,(u8*)&ctx.cciHdr) != Good){
fprintf(stderr,"[CCI ERROR] Failed to sign CCI\n");
return CCI_SIG_FAIL;
}
return 0;
}
int BuildCardInfoHeader(cci_settings *cciset, user_settings *usrset)
{
u32_to_u8((u8*)ctx.cardinfo.writableAddress,(cciset->writableAddress/cciset->mediaUnit),LE);
u32_to_u8((u8*)ctx.cardinfo.cardInfoBitmask,cciset->cardInfoBitmask,BE);
u32_to_u8((u8*)ctx.cardinfo.mediaSizeUsed,cciset->cciTotalSize,LE);
memcpy(ctx.cardinfo.cverTitleId,cciset->cverTitleId,8);
memcpy(ctx.cardinfo.cverTitleVersion,cciset->cverTitleVersion,2);
memcpy((u8*)ctx.cardinfo.ncch0TitleId,cciset->contentTitleId[0],8);
memcpy((u8*)ctx.cardinfo.initialData,cciset->initialData,0x30);
memcpy((u8*)ctx.cardinfo.ncch0Hdr,cciset->ncchHdr,0x100);
memcpy((u8*)ctx.devcardinfo.titleKey,cciset->titleKey,0x10);
return 0;
}
int WriteCCI_HDR_ToFile(cci_settings *cciset)
{
WriteBuffer(ctx.signature,0x100,0,cciset->out);
WriteBuffer((u8*)&ctx.cciHdr,sizeof(cci_hdr),0x100,cciset->out);
WriteBuffer((u8*)&ctx.cardinfo,sizeof(cardinfo_hdr),0x200,cciset->out);
if(memcmp(ctx.devcardinfo.titleKey,ctx.keys->aes.normalKey,16) == 0){
// Creating Buffer of Dummy Bytes
u64 len = cciset->contentOffset[0] - 0x1200;
u8 *dummy_bytes = malloc(len);
memset(dummy_bytes,0xff,len);
WriteBuffer(dummy_bytes,len,0x1200,cciset->out);
}
else
WriteBuffer((u8*)&ctx.devcardinfo,sizeof(devcardinfo_hdr),0x1200,cciset->out);
return 0;
}
int WriteCCI_Content_ToFile(cci_settings *cciset,user_settings *usrset)
{
// Write Content 0
WriteBuffer(cciset->ncch0,cciset->contentSize[0],cciset->contentOffset[0],cciset->out);
free(usrset->common.workingFile.buffer);
usrset->common.workingFile.buffer = NULL;
usrset->common.workingFile.size = 0;
// Add additional contents, recreating them with their new TitleID
for(int i = 1; i < 8; i++){
if(cciset->content[i]){
u8 *ncch = RetargetNCCH(cciset->content[i],cciset->contentSize[i],cciset->contentTitleId[i],cciset->mediaId,ctx.keys);
if(!ncch){
fprintf(stderr,"[CCI ERROR] Could not import content %d to CCI\n",i);
return FAILED_TO_IMPORT_FILE;
}
WriteBuffer(ncch,cciset->contentSize[i],cciset->contentOffset[i],cciset->out);
free(ncch);
}
}
return 0;
}
int WriteCCI_DummyBytes(cci_settings *cciset)
{
// Seeking end of CCI Data
fseek_64(cciset->out,cciset->cciTotalSize);
// Determining Size of Dummy Bytes
u64 len = cciset->mediaSize - cciset->cciTotalSize;
// Creating Buffer of Dummy Bytes
u8 *dummy_bytes = malloc(cciset->mediaUnit);
memset(dummy_bytes,0xff,cciset->mediaUnit);
// Writing Dummy Bytes to file
for(u64 i = 0; i < len; i += cciset->mediaUnit)
fwrite(dummy_bytes,cciset->mediaUnit,1,cciset->out);
return 0;
}
int GetContentFP(cci_settings *cciset, user_settings *usrset)
{
cciset->content = malloc(sizeof(FILE*)*8);
if(!cciset->content){
fprintf(stderr,"[CCI ERROR] Not enough memory\n");
return MEM_ERROR;
}
memset(cciset->content,0,sizeof(FILE*)*8);
for(int i = 1; i < 8; i++){
if(usrset->common.contentPath[i]){
cciset->content[i] = fopen(usrset->common.contentPath[i],"rb");
if(!cciset->content[i]){ // Checking if file could be opened
fprintf(stderr,"[CCI ERROR] Failed to open '%s'\n",usrset->common.contentPath[i]);
return FAILED_TO_OPEN_FILE;
}
if(!IsNCCH(cciset->content[i],NULL)){ // Checking if NCCH
fprintf(stderr,"[CCI ERROR] Content '%s' is invalid\n",usrset->common.contentPath[i]);
return NCSD_INVALID_NCCH0;
}
// Getting NCCH Header
ncch_hdr *hdr = malloc(sizeof(ncch_hdr));
GetNCCH_CommonHDR(hdr,cciset->content[i],NULL);
if(GetNCCH_MediaUnitSize(hdr) != cciset->mediaUnit){ // Checking if Media Unit Size matches CCI
fprintf(stderr,"[CCI ERROR] Content '%s' is invalid\n",usrset->common.contentPath[i]);
return NCSD_INVALID_NCCH0;
}
if(usrset->cci.dontModifyNcchTitleID)
memcpy(&cciset->contentTitleId[i],hdr->titleId,8);
else{
memcpy(&cciset->contentTitleId[i],cciset->mediaId,8); // Set TitleID
// Modify TitleID Accordingly
u16 tmp = u8_to_u16(&hdr->titleId[6],LE);
tmp |= (i+4);
u16_to_u8(&cciset->contentTitleId[i][6],tmp,LE);
}
cciset->contentSize[i] = GetNCCH_MediaSize(hdr)*cciset->mediaUnit;
cciset->contentOffset[i] = cciset->cciTotalSize;
cciset->cciTotalSize += cciset->contentSize[i];
free(hdr);
}
}
return 0;
}
int CheckContent0(cci_settings *cciset, user_settings *usrset)
{
if(!usrset->common.workingFile.buffer)
return NCSD_NO_NCCH0;
cciset->ncch0 = usrset->common.workingFile.buffer;
cciset->ncch0_FileLen = usrset->common.workingFile.size;
if(!IsNCCH(NULL,cciset->ncch0))
return NCSD_INVALID_NCCH0;
return 0;
}
int GetDataFromContent0(cci_settings *cciset, user_settings *usrset)
{
cciset->cciTotalSize = 0x4000;
ncch_hdr *hdr;
hdr = GetNCCH_CommonHDR(NULL,NULL,cciset->ncch0);
cciset->ncchHdr = hdr;
u16 ncch_format_ver = u8_to_u16(hdr->formatVersion,LE);
if(ncch_format_ver != 0 && ncch_format_ver != 2){
fprintf(stderr,"[CCI ERROR] NCCH type %d Not Supported\n",ncch_format_ver);
return FAILED_TO_IMPORT_FILE;
}
//memdump(stdout,"ncch0 head: ",(cciset->ncch0+0x100),0x100);
//memdump(stdout,"ncch0 head: ",(u8*)(hdr),0x100);
memcpy(cciset->mediaId,hdr->titleId,8);
memcpy(&cciset->contentTitleId[0],hdr->titleId,8);
if(usrset->cci.useSDKStockData){
memcpy(cciset->initialData,stock_initial_data,0x30);
memcpy(cciset->titleKey,stock_title_key,0x10);
}
else{
u8 Hash[0x40];
ctr_sha(cciset->ncch0,0x80,Hash,CTR_SHA_256);
ctr_sha((cciset->ncch0+0x80),0x80,(Hash+0x20),CTR_SHA_256);
memcpy(cciset->initialData,Hash,0x2C);
//memcpy(cciset->titleKey,(Hash+0x30),0x10); // Might Remove
}
cciset->flags[MediaUnitSize] = hdr->flags[ContentUnitSize];
cciset->mediaUnit = GetNCCH_MediaUnitSize(hdr);
cciset->contentSize[0] = (u64)(GetNCCH_MediaSize(hdr) * cciset->mediaUnit);
cciset->contentOffset[0] = cciset->cciTotalSize;
cciset->cciTotalSize += cciset->contentSize[0];
return 0;
}
int GetMediaSize(cci_settings *cciset, user_settings *usrset)
{
char *MediaSizeStr = usrset->common.rsfSet.BasicInfo.MediaSize;
if(!MediaSizeStr) cciset->mediaSize = (u64)GB*2;
else{
if(strcasecmp(MediaSizeStr,"128MB") == 0) cciset->mediaSize = (u64)MB*128;
else if(strcasecmp(MediaSizeStr,"256MB") == 0) cciset->mediaSize = (u64)MB*256;
else if(strcasecmp(MediaSizeStr,"512MB") == 0) cciset->mediaSize = (u64)MB*512;
else if(strcasecmp(MediaSizeStr,"1GB") == 0) cciset->mediaSize = (u64)GB*1;
else if(strcasecmp(MediaSizeStr,"2GB") == 0) cciset->mediaSize = (u64)GB*2;
else if(strcasecmp(MediaSizeStr,"4GB") == 0) cciset->mediaSize = (u64)GB*4;
else if(strcasecmp(MediaSizeStr,"8GB") == 0) cciset->mediaSize = (u64)GB*8;
else if(strcasecmp(MediaSizeStr,"16GB") == 0) cciset->mediaSize = (u64)GB*16;
else if(strcasecmp(MediaSizeStr,"32GB") == 0) cciset->mediaSize = (u64)GB*32;
else {
fprintf(stderr,"[CCI ERROR] Invalid MediaSize: %s\n",MediaSizeStr);
return INVALID_YAML_OPT;
}
}
if(usrset->common.rsfSet.BasicInfo.MediaFootPadding != -1) cciset->fillOutCci = usrset->common.rsfSet.BasicInfo.MediaFootPadding;
return 0;
}
u64 GetUnusedSize(u64 MediaSize, u8 CardType)
{
if(CardType == CARD1){
switch(MediaSize){
case (u64)MB*128: return (u64)2621440;
case (u64)MB*256: return (u64)5242880;
case (u64)MB*512: return (u64)10485760;
case (u64)GB*1: return (u64)73924608;
case (u64)GB*2: return (u64)147324928;
case (u64)GB*4: return (u64)294649856;
case (u64)GB*8: return (u64)587202560;
default: return (u64)((MediaSize/MB)*0x11800); // Aprox
}
}
else if(CardType == CARD2){
switch(MediaSize){
case (u64)MB*512: return (u64)37224448;
case (u64)GB*1: return (u64)73924608;
case (u64)GB*2: return (u64)147324928;
case (u64)GB*4: return (u64)294649856;
case (u64)GB*8: return (u64)587202560;
default: return (u64)((MediaSize/MB)*0x11800); // Aprox
}
}
return 0;
}
int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml)
{
/* BackupWriteWaitTime */
cciset->flags[FW6x_BackupWriteWaitTime] = 0;
if(yaml->CardInfo.BackupWriteWaitTime){
u32 WaitTime = strtoul(yaml->CardInfo.BackupWriteWaitTime,NULL,0);
if(WaitTime > 255){
fprintf(stderr,"[CCI ERROR] Invalid Card BackupWriteWaitTime (%d) : must 0-255\n",WaitTime);
return EXHDR_BAD_YAML_OPT;
}
cciset->flags[FW6x_BackupWriteWaitTime] = (u8)WaitTime;
}
/* MediaType */
if(!yaml->CardInfo.MediaType) cciset->flags[MediaTypeIndex] = CARD1;
else{
if(strcasecmp(yaml->CardInfo.MediaType,"Card1") == 0) cciset->flags[MediaTypeIndex] = CARD1;
else if(strcasecmp(yaml->CardInfo.MediaType,"Card2") == 0) cciset->flags[MediaTypeIndex] = CARD2;
else {
fprintf(stderr,"[CCI ERROR] Invalid MediaType: %s\n",yaml->CardInfo.MediaType);
return INVALID_YAML_OPT;
}
}
/* Platform */
cciset->flags[MediaPlatformIndex] = CTR;
u8 saveCrypto;
if(!yaml->CardInfo.SaveCrypto) saveCrypto = 3;
else{
if(strcasecmp(yaml->CardInfo.SaveCrypto,"fw1") == 0 || strcasecmp(yaml->CardInfo.SaveCrypto,"ctr fail") == 0 ) saveCrypto = 1;
else if(strcasecmp(yaml->CardInfo.SaveCrypto,"fw2") == 0) saveCrypto = 2;
else if(strcasecmp(yaml->CardInfo.SaveCrypto,"fw3") == 0) saveCrypto = 3;
else if(strcasecmp(yaml->CardInfo.SaveCrypto,"fw6") == 0) saveCrypto = 6;
else {
fprintf(stderr,"[CCI ERROR] Invalid SaveCrypto: %s\n",yaml->CardInfo.SaveCrypto);
return INVALID_YAML_OPT;
}
}
/* FW6x SaveCrypto */
cciset->flags[FW6x_SaveCryptoFlag] = saveCrypto == 6;
/* CardDevice */
if(saveCrypto > 1){
u8 flag = CardDeviceFlag;
if(saveCrypto == 2) flag = OldCardDeviceFlag;
if(!yaml->CardInfo.CardDevice) cciset->flags[flag] = CARD_DEVICE_NONE;
else{
if(strcmp(yaml->CardInfo.CardDevice,"NorFlash") == 0) {
cciset->flags[flag] = CARD_DEVICE_NOR_FLASH;
if(cciset->flags[MediaTypeIndex] == CARD2){
fprintf(stderr,"[CCI WARNING] 'CardDevice: NorFlash' is invalid on Card2\n");
cciset->flags[flag] = CARD_DEVICE_NONE;
}
}
else if(strcmp(yaml->CardInfo.CardDevice,"None") == 0) cciset->flags[flag] = CARD_DEVICE_NONE;
else if(strcmp(yaml->CardInfo.CardDevice,"BT") == 0) cciset->flags[flag] = CARD_DEVICE_BT;
else {
fprintf(stderr,"[CCI ERROR] Invalid CardDevice: %s\n",yaml->CardInfo.CardDevice);
return INVALID_YAML_OPT;
}
}
}
return 0;
}
int GetWriteableAddress(cci_settings *cciset, user_settings *usrset)
{
int result = GetSaveDataSize_rsf(&cciset->savedataSize,usrset);
if(result) return result;
char *WriteableAddressStr = usrset->common.rsfSet.CardInfo.WritableAddress;;
cciset->writableAddress = -1;
if(cciset->flags[MediaTypeIndex] != CARD2) return 0; // Can only be set for Card2 Media
if(WriteableAddressStr){
if(strncmp(WriteableAddressStr,"0x",2) != 0){
fprintf(stderr,"[CCI ERROR] WritableAddress requires a Hexadecimal value\n");
return INVALID_YAML_OPT;
}
cciset->writableAddress = strtoul((WriteableAddressStr+2),NULL,16);
}
if(cciset->writableAddress == -1){ // If not set manually or is max size
if ((cciset->mediaSize / 2) < cciset->savedataSize){ // If SaveData size is greater than half the MediaSize
u64 SavedataSize = cciset->savedataSize / KB;
fprintf(stderr,"[CCI ERROR] Too large SavedataSize %llK\n",SavedataSize);
return SAVE_DATA_TOO_LARGE;
}
if (cciset->savedataSize > (u64)(2047*MB)){ // Limit set by Nintendo
u64 SavedataSize = cciset->savedataSize / KB;
fprintf(stderr,"[CCI ERROR] Too large SavedataSize %llK\n",SavedataSize);
return SAVE_DATA_TOO_LARGE;
}
if(usrset->cci.closeAlignWritableRegion)
cciset->writableAddress = align(cciset->cciTotalSize, cciset->mediaUnit);
else{
u64 UnusedSize = GetUnusedSize(cciset->mediaSize,cciset->flags[MediaTypeIndex]); // Need to look into this
cciset->writableAddress = cciset->mediaSize - UnusedSize - cciset->savedataSize;
}
}
return 0;
}
int GetCardInfoBitmask(cci_settings *cciset, user_settings *usrset)
{
char *str = usrset->common.rsfSet.CardInfo.CardType;
if(!str) cciset->cardInfoBitmask |= 0;
else{
if(strcasecmp(str,"s1") == 0) cciset->cardInfoBitmask |= 0;
else if(strcasecmp(str,"s2") == 0) cciset->cardInfoBitmask |= 0x20;
else {
fprintf(stderr,"[CCI ERROR] Invalid CardType: %s\n",str);
return INVALID_YAML_OPT;
}
}
str = usrset->common.rsfSet.CardInfo.CryptoType;
if(!str) cciset->cardInfoBitmask |= (3*0x40);
else{
int Value = strtol(str,NULL,10);
if(Value < 0 || Value > 3) {
fprintf(stderr,"[CCI ERROR] Invalid CryptoType: %s\n",str);
return INVALID_YAML_OPT;
}
if(Value != 3){
fprintf(stderr,"[CCI WARNING] Card crypto type = '%d'\n",Value);
}
cciset->cardInfoBitmask |= (Value*0x40);
}
return 0;
}
int ImportCverDetails(cci_settings *cciset, user_settings *usrset)
{
if(!usrset->cci.cverCiaPath){
memset(cciset->cverTitleId,0,8);
memset(cciset->cverTitleVersion,0,2);
return 0;
}
if(!DoesFileExist(usrset->cci.cverCiaPath)){
fprintf(stderr,"[NCSD ERROR] Failed to open \"%s\"\n",usrset->cci.cverCiaPath);
return FAILED_TO_IMPORT_FILE;
}
FILE *cia = fopen(usrset->cci.cverCiaPath,"rb");
cia_hdr *ciaHdr = calloc(1,sizeof(cia_hdr));
ReadFile_64(ciaHdr,sizeof(cia_hdr),0,cia);
u64 tmdSize = GetTmdSize(ciaHdr);
u64 tmdOffset = GetTmdOffset(ciaHdr);
u8 *tmd = calloc(1,tmdSize);
ReadFile_64(tmd,tmdSize,tmdOffset,cia);
tmd_hdr *tmdHdr = GetTmdHdr(tmd);
memdump(stdout,"tmd: ",(u8*)tmdHdr,sizeof(tmd_hdr));
endian_memcpy(cciset->cverTitleId,tmdHdr->titleID,8,LE);
endian_memcpy(cciset->cverTitleVersion,tmdHdr->titleVersion,2,LE);
fclose(cia);
free(ciaHdr);
free(tmd);
return 0;
}
int CheckMediaSize(cci_settings *cciset)
{
if(cciset->cciTotalSize > cciset->mediaSize){
char *MediaSizeStr = NULL;
switch(cciset->mediaSize){
case (u64)128*MB: MediaSizeStr = " '128MB'"; break;
case (u64)256*MB: MediaSizeStr = " '256MB'"; break;
case (u64)512*MB: MediaSizeStr = " '512MB'"; break;
case (u64)1*GB: MediaSizeStr = " '1GB'"; break;
case (u64)2*GB: MediaSizeStr = " '2GB'"; break;
case (u64)4*GB: MediaSizeStr = " '4GB'"; break;
case (u64)8*GB: MediaSizeStr = " '8GB'"; break;
case (u64)16*GB: MediaSizeStr = " '16GB'"; break;
case (u64)32*GB: MediaSizeStr = " '32GB'"; break;
default: MediaSizeStr = ""; break;
}
fprintf(stderr,"[CCI ERROR] MediaSize%s is too Small\n",MediaSizeStr);
return INVALID_YAML_OPT;
}
return 0;
}
bool IsCci(u8 *ncsd)
{
cci_hdr *hdr = (cci_hdr*)(ncsd+0x100);
if(!hdr) return false;
if(memcmp(hdr->magic,"NCSD",4)!=0) return false;
if(hdr->partitionFlags[MediaPlatformIndex] != CTR) return false;
if(hdr->partitionFlags[MediaTypeIndex] != CARD1 && hdr->partitionFlags[MediaTypeIndex] != CARD2) return false;
return true;
}
u8* GetPartition(u8 *ncsd, u8 index)
{
return (u8*)(ncsd+GetPartitionOffset(ncsd,index));
}
u64 GetPartitionOffset(u8 *ncsd, u8 index)
{
cci_hdr *hdr = (cci_hdr*)(ncsd+0x100);
u32 media_size = 0x200*pow(2,hdr->partitionFlags[MediaUnitSize]);
u32 offset = u8_to_u64(hdr->offset_sizeTable[index].offset,LE);
return offset*media_size;
}
u64 GetPartitionSize(u8 *ncsd, u8 index)
{
cci_hdr *hdr = (cci_hdr*)(ncsd+0x100);
u32 media_size = 0x200*pow(2,hdr->partitionFlags[MediaUnitSize]);
u32 size = u8_to_u64(hdr->offset_sizeTable[index].size,LE);
return size*media_size;
}
Reference in New Issue View Git Blame Copy Permalink