DarkStore-3DS/Project_CTR
1
0
Fork 0
mirror of https://github.com/DarkStore-3DS/Project_CTR.git synced 2026-07-02 16:59:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

makerom v0.3

Browse Source
This commit is contained in:
3DSGuy
2014-03-10 10:30:00 +08:00
parent 3c9fffd56a
commit 510988b07a
26 changed files with 1983 additions and 833 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Application.rsf
+89
View File
@@ -0,0 +1,89 @@
# Default value for application
BasicInfo:
Title : "Homebrew"
CompanyCode : "00"
MediaSize : 128MB # 128MB / 256MB / 512MB / 1GB / 2GB
MediaFootPadding: false
ProductCode : "CTR-P-HAXX"
ContentType : Application # Application / SystemUpdate / Manual / Child / Trial
Logo : Licensed # Nintendo / Licensed / Distributed
BackupMemoryType: None # None / 128KB / 512KB
Rom:
# Specifies the root path of the file system to include in the ROM.
#HostRoot: "$(ROMFS_ROOT)"
SaveDataSize: 512KB
DefaultReject:
- .*
File:
- "*"
TitleInfo:
UniqueId: 0xff3ff
#TargetCategory: Contents
Category: Application
#DemoIndex: 1
Version: 0
CardInfo:
#WritableAddress: 0x200
#CardType : S2 # S1 / S2
#CryptoType : 3 # 0 - 3
CardDevice : NorFlash # NorFlash(0), None(1), BT(2)
#MediaType : CARD1 # Card1 / Card2
BackupWriteWaitTime: 0
Option:
UseOnSD: true # true if App is to be installed to SD
EnableCompress: true
FreeProductCode: true
EnableCrypt : false
ExeFs:
ReadOnly:
- .rodata
- RO
ReadWrite:
- .data
- RO
Text:
- .text
- STUP_ENTRY
PlainRegion:
- .module_id
AccessControlInfo:
#UseOtherVariationSaveData : true
#UseExtSaveData : true
#ExtSaveDataId: 0xffffffff
SystemSaveDataId1: 0x220
SystemSaveDataId2: 0x00040010
#OtherUserSaveDataId1: 0x220
#OtherUserSaveDataId2: 0x330
#OtherUserSaveDataId3: 0x440
UseExtendedSaveDataAccessControl: true
AccessibleSaveDataIds: [0x101, 0x202, 0x303, 0x404, 0x505, 0x606]
FileSystemAccess:
#- CategorySystemApplication #0x1
#- CategoryHardwareCheck #0x2
#- CategoryFileSystemTool #0x4
- Debug #0x8
#- TwlCardBackup #0x10
#- TwlNandData #0x20
#- Boss #0x40
- DirectSdmc #0x80
#- Core #0x100
#- CtrNandRo #0x200
#- CtrNandRw #0x400
#- CtrNandRoWrite #0x800
#- CategorySystemSettings #0x1000
#- CardBoard #0x2000
#- ExportImportIvs #0x4000
- DirectSdmcWrite #0x8000
SystemControlInfo:
RemasterVersion: 5
StackSize: 0x40000
#JumpId: 0
sdapp_FW4X.rsf → Application2.rsf
+128 -33
View File
@@ -1,51 +1,111 @@
# Default value for application
BasicInfo:
Title : "Pyramids"
Title : "Homebrew"
CompanyCode : "00"
ProductCode : "CTR-T-JA9P"
MediaSize : 128MB # 128MB / 256MB / 512MB / 1GB / 2GB
MediaFootPadding: false
ProductCode : "CTR-P-HAXX"
ContentType : Application # Application / SystemUpdate / Manual / Child / Trial
Logo : Licensed # Nintendo / Licensed / Distributed / iQue / iQueForSystem
Logo : Licensed # Nintendo / Licensed / Distributed
BackupMemoryType: None # None / 128KB / 512KB
Rom:
# Specifies the root path of the file system to include in the ROM.
#HostRoot: "$(ROMFS_ROOT)"
SaveDataSize: 512KB
DefaultReject:
- .*
File:
- "*"
TitleInfo:
UniqueId: 0xff3ff
#TargetCategory: Contents
Category: Application
UniqueId: 0x60f
#DemoIndex: 1
Version: 0
CardInfo:
#WritableAddress: 0x200
#CardType : S2 # S1 / S2
#CryptoType : 3 # 0 - 3
CardDevice : NorFlash # NorFlash(0), None(1), BT(2)
#MediaType : CARD1 # Card1 / Card2
BackupWriteWaitTime: 0
Option:
UseOnSD: true # true if App is to be installed to SD
EnableCompress: true
FreeProductCode: true
EnableCrypt : true
Rom:
SaveDataSize: 128KB
EnableCrypt : false
ExeFs:
ReadOnly:
- .rodata
#- RO
- RO
ReadWrite:
- .data
#- RW
- RO
Text:
- .text
#- STUP_ENTRY
- STUP_ENTRY
PlainRegion:
- .module_id
# Don't Modify Below here
AccessControlInfo:
MaxCpu: 0x9E
AffinityMask: 1
CoreVersion: 2
DescVersion: 2
HandleTableSize: 512
IORegisterMapping:
- 1ff50000-1ff57fff
- 1ff70000-1ff77fff
IdealProcessor: 0
MemoryMapping:
- 1f000000-1f5fffff:r
Priority: 16
AccessControlInfo:
MaxCpu: 0x0 # 0x9E
DisableDebug : true
EnableForceDebug : true
CanWriteSharedPage : true
CanUsePrivilegedPriority : true
CanUseNonAlphabetAndNumber : true
PermitMainFunctionArgument : true
CanShareDeviceMemory : true
#UseOtherVariationSaveData : true
#UseExtSaveData : true
RunnableOnSleep : true
SpecialMemoryArrange : true
#ExtSaveDataId: 0xffffffff
SystemSaveDataId1: 0x220
SystemSaveDataId2: 0x00040010
#OtherUserSaveDataId1: 0x220
#OtherUserSaveDataId2: 0x330
#OtherUserSaveDataId3: 0x440
UseExtendedSaveDataAccessControl: true
AccessibleSaveDataIds: [0x101, 0x202, 0x303, 0x404, 0x505, 0x606]
IoAccessControl:
- FsMountNand # 0x1
- FsMountNandRoWrite #0x2
- FsMountTwln #0x4
- FsMountWnand # 0x8
- FsMountCardSpi #0x10
- UseSdif3 # 0x20
- CreateSeed # 0x40
- UseCardSpi # 0x80
FileSystemAccess:
- CategorySystemApplication #0x1
- CategoryHardwareCheck #0x2
- CategoryFileSystemTool #0x4
- Debug #0x8
- TwlCardBackup #0x10
- TwlNandData #0x20
- Boss #0x40
- DirectSdmc #0x80
- Core #0x100
- CtrNandRo #0x200
- CtrNandRw #0x400
- CtrNandRoWrite #0x800
- CategorySystemSettings #0x1000
- CardBoard #0x2000
- ExportImportIvs #0x4000
- DirectSdmcWrite #0x8000
InterruptNumbers:
- 0x1
AffinityMask: 1
DescVersion: 2
DisableDebug: false
SystemCallAccess:
ArbitrateAddress: 34
Break: 60
@@ -98,9 +158,18 @@ AccessControlInfo:
UnmapMemoryBlock: 32
WaitSynchronization1: 36
WaitSynchronizationN: 37
HandleTableSize: 512
IORegisterMapping:
- 1ff50000-1ff57fff
- 1ff70000-1ff77fff
IdealProcessor: 0
MemoryMapping:
- 1f000000-1f5fffff:r
MemoryType: Application
Priority: 16
ProgramId: 0x00040000ffffff00L
ReleaseKernelMajor: "02"
ReleaseKernelMinor: "33"
ReleaseKernelMinor: "33"
ServiceAccessControl:
- APT:U
- $hioFIO
@@ -130,8 +199,12 @@ AccessControlInfo:
- y2r:u
- ldr:ro
- ir:USER
SystemControlInfo:
CoreVersion: 2
StorageId:
- 0
SystemControlInfo:
RemasterVersion: 5
Dependency:
ac: 0x0004013000002402L
am: 0x0004013000001502L
@@ -164,8 +237,8 @@ SystemControlInfo:
spi: 0x0004013000002302L
ssl: 0x0004013000002f02L
StackSize: 0x40000
CommonHeaderKey:
CommonHeaderKey:
D: |
jL2yO86eUQnYbXIrzgFVMm7FVze0LglZ2f5g+c42hWoEdnb5BOotaMQPBfqt
aUyAEmzQPaoi/4l4V+hTJRXQfthVRqIEx27B84l8LA6Tl5Fy9PaQaQ+4yRfP
@@ -173,6 +246,20 @@ CommonHeaderKey:
0RCb66lYcr2h/p2G7SnpKUliS9h9KnpmG+UEgVYQUK+4SCfByUa9PxYGpT0E
nw1UcRz0gsBmdOqcgzwnAd9vVqgb42hVn6uQZyAl+j1RKiMWywZarazIR/k5
Lmr4+groimSEa+3ajyoIho9WaWTDmFU3mkhA2tUDIQ==
DP: |
pD8c9uymjXDj6oyhx7EmQcrEDizxsj6hTjJ0x3G/PYNv/v2/DA9gp3X30h35
uRZ1O+SgonWCGVnOJ7Wfjr4w2cOcSzxpzT3PQsS6Gs9z0RvcDsUHRL5f2EiT
6A1ZPj6xyzmo9Ts6w9yfxCwaHci0f2hP9bq9FimfFKigCoNcFBE=
DQ: |
y+6Pado7N+SIZJgQ7zEGyQ7/SxGHHEy5uW04HHde9IqHD5HFGG2GegF655mM
iI9ja1eTCh/AFs8xjAg0drQEvB5q80TjPNKtwVUT8ghOlN3xTzpdaLwX0d+c
Twy74VY4KPawcdDeLaGFtXknhFOdGmIbx+BInibz7NZ9eLqGwaE=
Exponent: |
AQAB
InverseQ: |
tc9/lcF837g8AdfyeuCyuLyd36Zm1ZmJ1VSSuH8y3/1ZhBYZkOFXxU7EhMvJ
FyAu4qyCA9otzCXM+cqKxE3ZCkSconsXOu8szZTwuINSkwHlt22FtiTfPt+V
/g5kjtkjoZVOGfSvvfel9Smwy1yrFvKfi/yJsjATeNFjiEquV/w=
Modulus: |
z+yySANtuAnjXGxiLKlJ4fT0DGzD5S+dUKArWgDGcgALowRdlEbnABtIhbVh
LMl0yitDE8F4l1wzLwfHhfDa22CWUA98S3rXF53k5cOrb12leDKtBN2Wbtx1
@@ -180,6 +267,14 @@ CommonHeaderKey:
BEou29fQZEOc0HgRQYgz3TFikC0X8sapK5xwq9zTq13a7j1sDoH/9mdaRPms
Bz0jlHVlkyAMxXYdD2UGPSGi8JaAtwpJUzijXcB0PKTZQDaFH4zRLRX57ySp
fp2yHvigcoEXd3OxVn+tBaLSMFr1068PEEpS2AlHlw==
P: |
6SdD3AiAybNamgUgGJduyFWO1/LeakmoJm+23IEJADyU4nz+reGjxQnMrR+x
syuB8VPGuf1z0SInfRIu9PEjIfW9/H/fZ59GwckQuJbneODjW7KU1jM3cTVX
+AWvaxWDwlCUmVSYD2OySUJlo3szGmBYh/o/tKAq7kElaaOt+cc=
Q: |
5EyO8bCyfqgLTfipAG/nNLObQbqMyARdQfudxh4eQqHmzblEM3jareuA8eUZ
K8pIaP+U9UfxwWTeFsOulrpsm04j4gS71WGNx3YwOIRPXXOn7zBkxA3AO9qq
K8lMeV3gNsdt4Fz8Zh2F68HSP4avB+ThO2S18SXMyIkcM7Sbw7E=
Signature: |
3xyLmORvojVswxgXmPPOVH4ULn8e2G3PvClO/jIuwRGtRprGcOruKFUi4TYF
HASKzg8Mg4/I1t4RjurPrZvPgQ3rcROz066DAkwOEFBZPO5gBvuMf8IgJAFi
Makefile
+2 -2
View File
@@ -19,9 +19,9 @@ CFLAGS = --std=c99 -Wall -I. -DMAKEROM_VER_MAJOR=$(VER_MAJOR) -DMAKEROM_VER_MINO
CC = gcc
# MAKEROM Build Settings
MAKEROM_BUILD_FLAGS = -DPRIVATE_BUILD #-DRETAIL_FSIGN #-DELF_DEBUG
MAKEROM_BUILD_FLAGS = #-DDEBUG #-DELF_DEBUG
VER_MAJOR = 0
VER_MINOR = 2
VER_MINOR = 3
OUTPUT = makerom
main: build
accessdesc_sig.h
+179 -153
View File
File diff suppressed because one or more lines are too long
cia.c
+5 -1
View File
@@ -151,6 +151,11 @@ int GetSettingsFromUsrset(cia_settings *ciaset, user_settings *usrset)
ciaset->content.content0_FileLen = usrset->Content0.size;
u32_to_u8(ciaset->Title_type,TYPE_CTR,BE);
ciaset->content.EncryptContents = usrset->EncryptContents;
if(ciaset->keys->aes.CommonKey[ciaset->keys->aes.CurrentCommonKey] == NULL && ciaset->content.EncryptContents){
fprintf(stderr,"[CIA WARNING] Common Key could not be loaded, CIA will not be encrypted\n");
ciaset->content.EncryptContents = false;
}
ciaset->cert.ca_crl_version = 0;
ciaset->cert.signer_crl_version = 0;
@@ -172,7 +177,6 @@ int GetSettingsFromUsrset(cia_settings *ciaset, user_settings *usrset)
}
ciaset->tik.ticket_format_ver = 1;
ciaset->tik.UnknownDataType = tik_normal;
int result = GenCertChildIssuer(ciaset->tik.TicketIssuer,usrset->keys.certs.tik_cert);
if(result) return result;
cia.h
-1
View File
@@ -51,7 +51,6 @@ typedef struct
u8 DeviceID[8];
u8 TicketVersion[3];
u8 TitleKey[16];
u8 UnknownDataType;
} tik;
struct{
cia_certificates.h
+670
View File
@@ -0,0 +1,670 @@
#ifndef _CIA_CERTS_H_
#define _CIA_CERTS_H_
//RetailCerts
static const unsigned char ca3_dpki_cert[0x400] =
{
0x00, 0x01, 0x00, 0x03, 0x70, 0x41, 0x38, 0xEF,
0xBB, 0xBD, 0xA1, 0x6A, 0x98, 0x7D, 0xD9, 0x01,
0x32, 0x6D, 0x1C, 0x94, 0x59, 0x48, 0x4C, 0x88,
0xA2, 0x86, 0x1B, 0x91, 0xA3, 0x12, 0x58, 0x7A,
0xE7, 0x0E, 0xF6, 0x23, 0x7E, 0xC5, 0x0E, 0x10,
0x32, 0xDC, 0x39, 0xDD, 0xE8, 0x9A, 0x96, 0xA8,
0xE8, 0x59, 0xD7, 0x6A, 0x98, 0xA6, 0xE7, 0xE3,
0x6A, 0x0C, 0xFE, 0x35, 0x2C, 0xA8, 0x93, 0x05,
0x82, 0x34, 0xFF, 0x83, 0x3F, 0xCB, 0x3B, 0x03,
0x81, 0x1E, 0x9F, 0x0D, 0xC0, 0xD9, 0xA5, 0x2F,
0x80, 0x45, 0xB4, 0xB2, 0xF9, 0x41, 0x1B, 0x67,
0xA5, 0x1C, 0x44, 0xB5, 0xEF, 0x8C, 0xE7, 0x7B,
0xD6, 0xD5, 0x6B, 0xA7, 0x57, 0x34, 0xA1, 0x85,
0x6D, 0xE6, 0xD4, 0xBE, 0xD6, 0xD3, 0xA2, 0x42,
0xC7, 0xC8, 0x79, 0x1B, 0x34, 0x22, 0x37, 0x5E,
0x5C, 0x77, 0x9A, 0xBF, 0x07, 0x2F, 0x76, 0x95,
0xEF, 0xA0, 0xF7, 0x5B, 0xCB, 0x83, 0x78, 0x9F,
0xC3, 0x0E, 0x3F, 0xE4, 0xCC, 0x83, 0x92, 0x20,
0x78, 0x40, 0x63, 0x89, 0x49, 0xC7, 0xF6, 0x88,
0x56, 0x5F, 0x64, 0x9B, 0x74, 0xD6, 0x3D, 0x8D,
0x58, 0xFF, 0xAD, 0xDA, 0x57, 0x1E, 0x95, 0x54,
0x42, 0x6B, 0x13, 0x18, 0xFC, 0x46, 0x89, 0x83,
0xD4, 0xC8, 0xA5, 0x62, 0x8B, 0x06, 0xB6, 0xFC,
0x5D, 0x50, 0x7C, 0x13, 0xE7, 0xA1, 0x8A, 0xC1,
0x51, 0x1E, 0xB6, 0xD6, 0x2E, 0xA5, 0x44, 0x8F,
0x83, 0x50, 0x14, 0x47, 0xA9, 0xAF, 0xB3, 0xEC,
0xC2, 0x90, 0x3C, 0x9D, 0xD5, 0x2F, 0x92, 0x2A,
0xC9, 0xAC, 0xDB, 0xEF, 0x58, 0xC6, 0x02, 0x18,
0x48, 0xD9, 0x6E, 0x20, 0x87, 0x32, 0xD3, 0xD1,
0xD9, 0xD9, 0xEA, 0x44, 0x0D, 0x91, 0x62, 0x1C,
0x7A, 0x99, 0xDB, 0x88, 0x43, 0xC5, 0x9C, 0x1F,
0x2E, 0x2C, 0x7D, 0x9B, 0x57, 0x7D, 0x51, 0x2C,
0x16, 0x6D, 0x6F, 0x7E, 0x1A, 0xAD, 0x4A, 0x77,
0x4A, 0x37, 0x44, 0x7E, 0x78, 0xFE, 0x20, 0x21,
0xE1, 0x4A, 0x95, 0xD1, 0x12, 0xA0, 0x68, 0xAD,
0xA0, 0x19, 0xF4, 0x63, 0xC7, 0xA5, 0x56, 0x85,
0xAA, 0xBB, 0x68, 0x88, 0xB9, 0x24, 0x64, 0x83,
0xD1, 0x8B, 0x9C, 0x80, 0x6F, 0x47, 0x49, 0x18,
0x33, 0x17, 0x82, 0x34, 0x4A, 0x4B, 0x85, 0x31,
0x33, 0x4B, 0x26, 0x30, 0x32, 0x63, 0xD9, 0xD2,
0xEB, 0x4F, 0x4B, 0xB9, 0x96, 0x02, 0xB3, 0x52,
0xF6, 0xAE, 0x40, 0x46, 0xC6, 0x9A, 0x5E, 0x7E,
0x8E, 0x4A, 0x18, 0xEF, 0x9B, 0xC0, 0xA2, 0xDE,
0xD6, 0x13, 0x10, 0x41, 0x70, 0x12, 0xFD, 0x82,
0x4C, 0xC1, 0x16, 0xCF, 0xB7, 0xC4, 0xC1, 0xF7,
0xEC, 0x71, 0x77, 0xA1, 0x74, 0x46, 0xCB, 0xDE,
0x96, 0xF3, 0xED, 0xD8, 0x8F, 0xCD, 0x05, 0x2F,
0x0B, 0x88, 0x8A, 0x45, 0xFD, 0xAF, 0x2B, 0x63,
0x13, 0x54, 0xF4, 0x0D, 0x16, 0xE5, 0xFA, 0x9C,
0x2C, 0x4E, 0xDA, 0x98, 0xE7, 0x98, 0xD1, 0x5E,
0x60, 0x46, 0xDC, 0x53, 0x63, 0xF3, 0x09, 0x6B,
0x2C, 0x60, 0x7A, 0x9D, 0x8D, 0xD5, 0x5B, 0x15,
0x02, 0xA6, 0xAC, 0x7D, 0x3C, 0xC8, 0xD8, 0xC5,
0x75, 0x99, 0x8E, 0x7D, 0x79, 0x69, 0x10, 0xC8,
0x04, 0xC4, 0x95, 0x23, 0x50, 0x57, 0xE9, 0x1E,
0xCD, 0x26, 0x37, 0xC9, 0xC1, 0x84, 0x51, 0x51,
0xAC, 0x6B, 0x9A, 0x04, 0x90, 0xAE, 0x3E, 0xC6,
0xF4, 0x77, 0x40, 0xA0, 0xDB, 0x0B, 0xA3, 0x6D,
0x07, 0x59, 0x56, 0xCE, 0xE7, 0x35, 0x4E, 0xA3,
0xE9, 0xA4, 0xF2, 0x72, 0x0B, 0x26, 0x55, 0x0C,
0x7D, 0x39, 0x43, 0x24, 0xBC, 0x0C, 0xB7, 0xE9,
0x31, 0x7D, 0x8A, 0x86, 0x61, 0xF4, 0x21, 0x91,
0xFF, 0x10, 0xB0, 0x82, 0x56, 0xCE, 0x3F, 0xD2,
0x5B, 0x74, 0x5E, 0x51, 0x94, 0x90, 0x6B, 0x4D,
0x61, 0xCB, 0x4C, 0x2E, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x43, 0x41, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x7B, 0xE8, 0xEF, 0x6C,
0xB2, 0x79, 0xC9, 0xE2, 0xEE, 0xE1, 0x21, 0xC6,
0xEA, 0xF4, 0x4F, 0xF6, 0x39, 0xF8, 0x8F, 0x07,
0x8B, 0x4B, 0x77, 0xED, 0x9F, 0x95, 0x60, 0xB0,
0x35, 0x82, 0x81, 0xB5, 0x0E, 0x55, 0xAB, 0x72,
0x11, 0x15, 0xA1, 0x77, 0x70, 0x3C, 0x7A, 0x30,
0xFE, 0x3A, 0xE9, 0xEF, 0x1C, 0x60, 0xBC, 0x1D,
0x97, 0x46, 0x76, 0xB2, 0x3A, 0x68, 0xCC, 0x04,
0xB1, 0x98, 0x52, 0x5B, 0xC9, 0x68, 0xF1, 0x1D,
0xE2, 0xDB, 0x50, 0xE4, 0xD9, 0xE7, 0xF0, 0x71,
0xE5, 0x62, 0xDA, 0xE2, 0x09, 0x22, 0x33, 0xE9,
0xD3, 0x63, 0xF6, 0x1D, 0xD7, 0xC1, 0x9F, 0xF3,
0xA4, 0xA9, 0x1E, 0x8F, 0x65, 0x53, 0xD4, 0x71,
0xDD, 0x7B, 0x84, 0xB9, 0xF1, 0xB8, 0xCE, 0x73,
0x35, 0xF0, 0xF5, 0x54, 0x05, 0x63, 0xA1, 0xEA,
0xB8, 0x39, 0x63, 0xE0, 0x9B, 0xE9, 0x01, 0x01,
0x1F, 0x99, 0x54, 0x63, 0x61, 0x28, 0x70, 0x20,
0xE9, 0xCC, 0x0D, 0xAB, 0x48, 0x7F, 0x14, 0x0D,
0x66, 0x26, 0xA1, 0x83, 0x6D, 0x27, 0x11, 0x1F,
0x20, 0x68, 0xDE, 0x47, 0x72, 0x14, 0x91, 0x51,
0xCF, 0x69, 0xC6, 0x1B, 0xA6, 0x0E, 0xF9, 0xD9,
0x49, 0xA0, 0xF7, 0x1F, 0x54, 0x99, 0xF2, 0xD3,
0x9A, 0xD2, 0x8C, 0x70, 0x05, 0x34, 0x82, 0x93,
0xC4, 0x31, 0xFF, 0xBD, 0x33, 0xF6, 0xBC, 0xA6,
0x0D, 0xC7, 0x19, 0x5E, 0xA2, 0xBC, 0xC5, 0x6D,
0x20, 0x0B, 0xAF, 0x6D, 0x06, 0xD0, 0x9C, 0x41,
0xDB, 0x8D, 0xE9, 0xC7, 0x20, 0x15, 0x4C, 0xA4,
0x83, 0x2B, 0x69, 0xC0, 0x8C, 0x69, 0xCD, 0x3B,
0x07, 0x3A, 0x00, 0x63, 0x60, 0x2F, 0x46, 0x2D,
0x33, 0x80, 0x61, 0xA5, 0xEA, 0x6C, 0x91, 0x5C,
0xD5, 0x62, 0x35, 0x79, 0xC3, 0xEB, 0x64, 0xCE,
0x44, 0xEF, 0x58, 0x6D, 0x14, 0xBA, 0xAA, 0x88,
0x34, 0x01, 0x9B, 0x3E, 0xEB, 0xEE, 0xD3, 0x79,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const unsigned char xsC_dpki_cert[0x300] =
{
0x00, 0x01, 0x00, 0x04, 0x91, 0x9E, 0xBE, 0x46,
0x4A, 0xD0, 0xF5, 0x52, 0xCD, 0x1B, 0x72, 0xE7,
0x88, 0x49, 0x10, 0xCF, 0x55, 0xA9, 0xF0, 0x2E,
0x50, 0x78, 0x96, 0x41, 0xD8, 0x96, 0x68, 0x3D,
0xC0, 0x05, 0xBD, 0x0A, 0xEA, 0x87, 0x07, 0x9D,
0x8A, 0xC2, 0x84, 0xC6, 0x75, 0x06, 0x5F, 0x74,
0xC8, 0xBF, 0x37, 0xC8, 0x80, 0x44, 0x40, 0x95,
0x02, 0xA0, 0x22, 0x98, 0x0B, 0xB8, 0xAD, 0x48,
0x38, 0x3F, 0x6D, 0x28, 0xA7, 0x9D, 0xE3, 0x96,
0x26, 0xCC, 0xB2, 0xB2, 0x2A, 0x0F, 0x19, 0xE4,
0x10, 0x32, 0xF0, 0x94, 0xB3, 0x9F, 0xF0, 0x13,
0x31, 0x46, 0xDE, 0xC8, 0xF6, 0xC1, 0xA9, 0xD5,
0x5C, 0xD2, 0x8D, 0x9E, 0x1C, 0x47, 0xB3, 0xD1,
0x1F, 0x4F, 0x54, 0x26, 0xC2, 0xC7, 0x80, 0x13,
0x5A, 0x27, 0x75, 0xD3, 0xCA, 0x67, 0x9B, 0xC7,
0xE8, 0x34, 0xF0, 0xE0, 0xFB, 0x58, 0xE6, 0x88,
0x60, 0xA7, 0x13, 0x30, 0xFC, 0x95, 0x79, 0x17,
0x93, 0xC8, 0xFB, 0xA9, 0x35, 0xA7, 0xA6, 0x90,
0x8F, 0x22, 0x9D, 0xEE, 0x2A, 0x0C, 0xA6, 0xB9,
0xB2, 0x3B, 0x12, 0xD4, 0x95, 0xA6, 0xFE, 0x19,
0xD0, 0xD7, 0x26, 0x48, 0x21, 0x68, 0x78, 0x60,
0x5A, 0x66, 0x53, 0x8D, 0xBF, 0x37, 0x68, 0x99,
0x90, 0x5D, 0x34, 0x45, 0xFC, 0x5C, 0x72, 0x7A,
0x0E, 0x13, 0xE0, 0xE2, 0xC8, 0x97, 0x1C, 0x9C,
0xFA, 0x6C, 0x60, 0x67, 0x88, 0x75, 0x73, 0x2A,
0x4E, 0x75, 0x52, 0x3D, 0x2F, 0x56, 0x2F, 0x12,
0xAA, 0xBD, 0x15, 0x73, 0xBF, 0x06, 0xC9, 0x40,
0x54, 0xAE, 0xFA, 0x81, 0xA7, 0x14, 0x17, 0xAF,
0x9A, 0x4A, 0x06, 0x6D, 0x0F, 0xFC, 0x5A, 0xD6,
0x4B, 0xAB, 0x28, 0xB1, 0xFF, 0x60, 0x66, 0x1F,
0x44, 0x37, 0xD4, 0x9E, 0x1E, 0x0D, 0x94, 0x12,
0xEB, 0x4B, 0xCA, 0xCF, 0x4C, 0xFD, 0x6A, 0x34,
0x08, 0x84, 0x79, 0x82, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x2D, 0x43, 0x41, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x58, 0x53, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x63, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x13, 0x7A, 0x08, 0x94,
0xAD, 0x50, 0x5B, 0xB6, 0xC6, 0x7E, 0x2E, 0x5B,
0xDD, 0x6A, 0x3B, 0xEC, 0x43, 0xD9, 0x10, 0xC7,
0x72, 0xE9, 0xCC, 0x29, 0x0D, 0xA5, 0x85, 0x88,
0xB7, 0x7D, 0xCC, 0x11, 0x68, 0x0B, 0xB3, 0xE2,
0x9F, 0x4E, 0xAB, 0xBB, 0x26, 0xE9, 0x8C, 0x26,
0x01, 0x98, 0x5C, 0x04, 0x1B, 0xB1, 0x43, 0x78,
0xE6, 0x89, 0x18, 0x1A, 0xAD, 0x77, 0x05, 0x68,
0xE9, 0x28, 0xA2, 0xB9, 0x81, 0x67, 0xEE, 0x3E,
0x10, 0xD0, 0x72, 0xBE, 0xEF, 0x1F, 0xA2, 0x2F,
0xA2, 0xAA, 0x3E, 0x13, 0xF1, 0x1E, 0x18, 0x36,
0xA9, 0x2A, 0x42, 0x81, 0xEF, 0x70, 0xAA, 0xF4,
0xE4, 0x62, 0x99, 0x82, 0x21, 0xC6, 0xFB, 0xB9,
0xBD, 0xD0, 0x17, 0xE6, 0xAC, 0x59, 0x04, 0x94,
0xE9, 0xCE, 0xA9, 0x85, 0x9C, 0xEB, 0x2D, 0x2A,
0x4C, 0x17, 0x66, 0xF2, 0xC3, 0x39, 0x12, 0xC5,
0x8F, 0x14, 0xA8, 0x03, 0xE3, 0x6F, 0xCC, 0xDC,
0xCC, 0xDC, 0x13, 0xFD, 0x7A, 0xE7, 0x7C, 0x7A,
0x78, 0xD9, 0x97, 0xE6, 0xAC, 0xC3, 0x55, 0x57,
0xE0, 0xD3, 0xE9, 0xEB, 0x64, 0xB4, 0x3C, 0x92,
0xF4, 0xC5, 0x0D, 0x67, 0xA6, 0x02, 0xDE, 0xB3,
0x91, 0xB0, 0x66, 0x61, 0xCD, 0x32, 0x88, 0x0B,
0xD6, 0x49, 0x12, 0xAF, 0x1C, 0xBC, 0xB7, 0x16,
0x2A, 0x06, 0xF0, 0x25, 0x65, 0xD3, 0xB0, 0xEC,
0xE4, 0xFC, 0xEC, 0xDD, 0xAE, 0x8A, 0x49, 0x34,
0xDB, 0x8E, 0xE6, 0x7F, 0x30, 0x17, 0x98, 0x62,
0x21, 0x15, 0x5D, 0x13, 0x1C, 0x6C, 0x3F, 0x09,
0xAB, 0x19, 0x45, 0xC2, 0x06, 0xAC, 0x70, 0xC9,
0x42, 0xB3, 0x6F, 0x49, 0xA1, 0x18, 0x3B, 0xCD,
0x78, 0xB6, 0xE4, 0xB4, 0x7C, 0x6C, 0x5C, 0xAC,
0x0F, 0x8D, 0x62, 0xF8, 0x97, 0xC6, 0x95, 0x3D,
0xD1, 0x2F, 0x28, 0xB7, 0x0C, 0x5B, 0x7D, 0xF7,
0x51, 0x81, 0x9A, 0x98, 0x34, 0x65, 0x26, 0x25,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const unsigned char cpB_dpki_cert[0x300] =
{
0x00, 0x01, 0x00, 0x04, 0x2E, 0xA6, 0x6C, 0x66,
0xCF, 0xF3, 0x35, 0x79, 0x7D, 0x04, 0x97, 0xB7,
0x7A, 0x19, 0x7F, 0x9F, 0xE5, 0x1A, 0xB5, 0xA4,
0x13, 0x75, 0xDC, 0x73, 0xFD, 0x9E, 0x0B, 0x10,
0x66, 0x9B, 0x1B, 0x9A, 0x5B, 0x7E, 0x8A, 0xB2,
0x8F, 0x01, 0xB6, 0x7B, 0x62, 0x54, 0xC1, 0x4A,
0xA1, 0x33, 0x14, 0x18, 0xF2, 0x5B, 0xA5, 0x49,
0x00, 0x4C, 0x37, 0x8D, 0xD7, 0x2F, 0x0C, 0xE6,
0x3B, 0x1F, 0x70, 0x91, 0xAA, 0xFE, 0x38, 0x09,
0xB7, 0xAC, 0x6C, 0x28, 0x76, 0xA6, 0x1D, 0x60,
0x51, 0x6C, 0x43, 0xA6, 0x37, 0x29, 0x16, 0x2D,
0x28, 0x0B, 0xE2, 0x1B, 0xE8, 0xE2, 0xFE, 0x05,
0x7D, 0x8E, 0xB6, 0xE2, 0x04, 0x24, 0x22, 0x45,
0x73, 0x1A, 0xB6, 0xFE, 0xE3, 0x0E, 0x53, 0x35,
0x37, 0x3E, 0xEB, 0xA9, 0x70, 0xD5, 0x31, 0xBB,
0xA2, 0xCB, 0x22, 0x2D, 0x96, 0x84, 0x38, 0x7D,
0x5F, 0x2A, 0x1B, 0xF7, 0x52, 0x00, 0xCE, 0x06,
0x56, 0xE3, 0x90, 0xCE, 0x19, 0x13, 0x5B, 0x59,
0xE1, 0x4F, 0x0F, 0xA5, 0xC1, 0x28, 0x1A, 0x73,
0x86, 0xCC, 0xD1, 0xC8, 0xEC, 0x3F, 0xAD, 0x70,
0xFB, 0xCE, 0x74, 0xDE, 0xEE, 0x1F, 0xD0, 0x5F,
0x46, 0x33, 0x0B, 0x51, 0xF9, 0xB7, 0x9E, 0x1D,
0xDB, 0xF4, 0xE3, 0x3F, 0x14, 0x88, 0x9D, 0x05,
0x28, 0x29, 0x24, 0xC5, 0xF5, 0xDC, 0x27, 0x66,
0xEF, 0x06, 0x27, 0xD7, 0xEE, 0xDC, 0x73, 0x6E,
0x67, 0xC2, 0xE5, 0xB9, 0x38, 0x34, 0x66, 0x80,
0x72, 0x21, 0x6D, 0x1C, 0x78, 0xB8, 0x23, 0xA0,
0x72, 0xD3, 0x4F, 0xF3, 0xEC, 0xF9, 0xBD, 0x11,
0xA2, 0x9A, 0xF1, 0x6C, 0x33, 0xBD, 0x09, 0xAF,
0xB2, 0xD7, 0x4D, 0x53, 0x4E, 0x02, 0x7C, 0x19,
0x24, 0x0D, 0x59, 0x5A, 0x68, 0xEB, 0xB3, 0x05,
0xAC, 0xC4, 0x4A, 0xB3, 0x8A, 0xB8, 0x20, 0xC6,
0xD4, 0x26, 0x56, 0x0C, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x2D, 0x43, 0x41, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x43, 0x50, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x62, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x13, 0x7A, 0x08, 0x0B,
0xA6, 0x89, 0xC5, 0x90, 0xFD, 0x0B, 0x2F, 0x0D,
0x4F, 0x56, 0xB6, 0x32, 0xFB, 0x93, 0x4E, 0xD0,
0x73, 0x95, 0x17, 0xB3, 0x3A, 0x79, 0xDE, 0x04,
0x0E, 0xE9, 0x2D, 0xC3, 0x1D, 0x37, 0xC7, 0xF7,
0x3B, 0xF0, 0x4B, 0xD3, 0xE4, 0x4E, 0x20, 0xAB,
0x5A, 0x6F, 0xEA, 0xF5, 0x98, 0x4C, 0xC1, 0xF6,
0x06, 0x2E, 0x9A, 0x9F, 0xE5, 0x6C, 0x32, 0x85,
0xDC, 0x6F, 0x25, 0xDD, 0xD5, 0xD0, 0xBF, 0x9F,
0xE2, 0xEF, 0xE8, 0x35, 0xDF, 0x26, 0x34, 0xED,
0x93, 0x7F, 0xAB, 0x02, 0x14, 0xD1, 0x04, 0x80,
0x9C, 0xF7, 0x4B, 0x86, 0x0E, 0x6B, 0x04, 0x83,
0xF4, 0xCD, 0x2D, 0xAB, 0x2A, 0x96, 0x02, 0xBC,
0x56, 0xF0, 0xD6, 0xBD, 0x94, 0x6A, 0xED, 0x6E,
0x0B, 0xE4, 0xF0, 0x8F, 0x26, 0x68, 0x6B, 0xD0,
0x9E, 0xF7, 0xDB, 0x32, 0x5F, 0x82, 0xB1, 0x8F,
0x6A, 0xF2, 0xED, 0x52, 0x5B, 0xFD, 0x82, 0x8B,
0x65, 0x3F, 0xEE, 0x6E, 0xCE, 0x40, 0x0D, 0x5A,
0x48, 0xFF, 0xE2, 0x2D, 0x53, 0x8B, 0xB5, 0x33,
0x5B, 0x41, 0x53, 0x34, 0x2D, 0x43, 0x35, 0xAC,
0xF5, 0x90, 0xD0, 0xD3, 0x0A, 0xE2, 0x04, 0x3C,
0x7F, 0x5A, 0xD2, 0x14, 0xFC, 0x9C, 0x0F, 0xE6,
0xFA, 0x40, 0xA5, 0xC8, 0x65, 0x06, 0xCA, 0x63,
0x69, 0xBC, 0xEE, 0x44, 0xA3, 0x2D, 0x9E, 0x69,
0x5C, 0xF0, 0x0B, 0x4F, 0xD7, 0x9A, 0xDB, 0x56,
0x8D, 0x14, 0x9C, 0x20, 0x28, 0xA1, 0x4C, 0x9D,
0x71, 0xB8, 0x50, 0xCA, 0x36, 0x5B, 0x37, 0xF7,
0x0B, 0x65, 0x77, 0x91, 0xFC, 0x5D, 0x72, 0x8C,
0x4E, 0x18, 0xFD, 0x22, 0x55, 0x7C, 0x40, 0x62,
0xD7, 0x47, 0x71, 0x53, 0x3C, 0x70, 0x17, 0x9D,
0x3D, 0xAE, 0x8F, 0x92, 0xB1, 0x17, 0xE4, 0x5C,
0xB3, 0x32, 0xF3, 0xB3, 0xC2, 0xA2, 0x2E, 0x70,
0x5C, 0xFE, 0xC6, 0x6F, 0x6D, 0xA3, 0x77, 0x2B,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
//DevCerts
static const unsigned char ca4_dpki_cert[0x400] =
{
0x00, 0x01, 0x00, 0x03, 0x19, 0x49, 0x42, 0x9D,
0x1E, 0x58, 0xA6, 0x2E, 0x7E, 0x8B, 0x56, 0xD1,
0xB7, 0x6A, 0xE3, 0x02, 0xFD, 0x8B, 0x97, 0x49,
0x1F, 0x77, 0x87, 0x45, 0xF7, 0x53, 0x88, 0xC4,
0xDD, 0x0B, 0xEB, 0x1D, 0xF1, 0x22, 0xFB, 0x96,
0x42, 0x15, 0x14, 0x97, 0x76, 0x4A, 0x53, 0xCF,
0x78, 0x15, 0x18, 0x45, 0xE4, 0x2C, 0xA8, 0xFD,
0xE4, 0x86, 0xFD, 0x2A, 0x4F, 0x53, 0xF8, 0xA1,
0xBA, 0x00, 0x8A, 0x74, 0x85, 0xFF, 0x73, 0xB3,
0xBF, 0x7E, 0x3C, 0x98, 0x07, 0x29, 0xD0, 0x65,
0x6B, 0x69, 0x32, 0x19, 0xAD, 0xE8, 0x35, 0xEB,
0x5F, 0xFF, 0xFC, 0xCB, 0x7C, 0xBB, 0x5E, 0x30,
0x7F, 0xE0, 0x68, 0x8B, 0x88, 0x8E, 0xF2, 0xD2,
0x05, 0x3F, 0xB7, 0xE7, 0x91, 0xE9, 0x85, 0xFD,
0x15, 0xEF, 0x10, 0xD7, 0x9C, 0xCA, 0x88, 0xD6,
0xBB, 0x15, 0xE8, 0xE4, 0x71, 0x4A, 0x98, 0xEE,
0x09, 0xBF, 0x7B, 0x8A, 0xF0, 0x53, 0x23, 0x2B,
0x64, 0x50, 0xE6, 0xD5, 0xFD, 0xFF, 0xC2, 0x0A,
0x6D, 0x1E, 0xA6, 0xA2, 0x38, 0x12, 0xE1, 0x01,
0x45, 0x25, 0xD5, 0x6D, 0x40, 0x82, 0x70, 0x3B,
0x86, 0x98, 0x69, 0x59, 0xA7, 0x3C, 0xD1, 0xA1,
0x43, 0x64, 0xD2, 0xC2, 0xDA, 0xEA, 0x96, 0xB0,
0x95, 0xF7, 0x6C, 0x46, 0xE4, 0xFF, 0x41, 0x55,
0x46, 0x5E, 0x70, 0xEF, 0x1E, 0xD3, 0x10, 0x53,
0xD9, 0x70, 0x11, 0xE0, 0x10, 0xCC, 0x93, 0xE7,
0x91, 0x40, 0x13, 0x68, 0x7F, 0xA3, 0xA8, 0x02,
0x99, 0x6D, 0x1E, 0x55, 0x7B, 0x1C, 0xCC, 0x7A,
0x7E, 0x8F, 0x58, 0x65, 0xC1, 0x74, 0x2E, 0x28,
0xE2, 0x6D, 0xEF, 0x38, 0xA9, 0x3A, 0xB5, 0xD8,
0x2D, 0x43, 0xEC, 0xCC, 0xBF, 0x0B, 0xEF, 0x22,
0xE1, 0xFD, 0x57, 0xE2, 0x86, 0x43, 0x33, 0x58,
0x2F, 0xED, 0xEA, 0xBC, 0x01, 0x2F, 0x98, 0x6D,
0xDF, 0xC3, 0xE9, 0x44, 0x79, 0x73, 0x47, 0x03,
0x08, 0x45, 0x5B, 0xDC, 0x57, 0xAA, 0x17, 0x0B,
0x84, 0x42, 0x7F, 0x73, 0xA2, 0x9B, 0x48, 0xF6,
0xDA, 0x13, 0x5F, 0x66, 0xC7, 0x45, 0xC1, 0x42,
0xA8, 0x4A, 0xFB, 0x0E, 0x6A, 0x5E, 0xED, 0x85,
0xD7, 0xB9, 0x71, 0x99, 0x36, 0xF8, 0xCE, 0x2B,
0x62, 0x1F, 0x39, 0x5F, 0x40, 0xDC, 0x03, 0xBE,
0xF8, 0x85, 0x4C, 0x11, 0x17, 0xFF, 0x0C, 0x12,
0x86, 0x41, 0xCC, 0x78, 0x43, 0xB9, 0x7B, 0x43,
0x46, 0xDB, 0x22, 0x6F, 0x60, 0x26, 0xAC, 0xB5,
0x6C, 0x27, 0x8B, 0x8E, 0x0E, 0xA7, 0x9A, 0x2D,
0x65, 0xEF, 0x79, 0x8E, 0x10, 0x78, 0xAD, 0x80,
0xED, 0x4B, 0x96, 0x04, 0xD2, 0xF0, 0x8B, 0x2C,
0xD6, 0x4A, 0x23, 0xA3, 0xDB, 0x27, 0x08, 0x33,
0xB4, 0x02, 0xF8, 0x08, 0x51, 0xF3, 0x5B, 0xED,
0x3E, 0xE4, 0x57, 0x7C, 0x66, 0x60, 0xFB, 0xF1,
0x6D, 0x94, 0x13, 0xE0, 0x9C, 0x91, 0x7A, 0x49,
0xD4, 0x2C, 0x6D, 0xA3, 0x75, 0xBC, 0x27, 0xF0,
0x23, 0x0D, 0xB9, 0x8F, 0x89, 0x73, 0xAB, 0x02,
0x7B, 0x52, 0x2C, 0xD5, 0x7E, 0xC0, 0x3D, 0x25,
0xE8, 0xB3, 0xFC, 0x34, 0x94, 0xC9, 0x7F, 0xB1,
0x08, 0xFE, 0x18, 0xC6, 0x8A, 0x43, 0x36, 0xE4,
0x6C, 0x26, 0xB6, 0xF2, 0x80, 0xD2, 0x7E, 0x34,
0xBE, 0x28, 0x7C, 0x3E, 0x46, 0x87, 0xBC, 0x9D,
0x77, 0x6B, 0x76, 0xD9, 0x28, 0xD1, 0xB6, 0x35,
0x2E, 0xC0, 0x34, 0x7D, 0x72, 0x94, 0xAA, 0x93,
0x60, 0x26, 0x8D, 0x26, 0xF5, 0xF6, 0x52, 0x06,
0x4A, 0xF2, 0x40, 0xD7, 0xD0, 0x0C, 0x7C, 0x5E,
0xA3, 0xC3, 0x2D, 0xE6, 0x2D, 0x9B, 0x5C, 0x4B,
0x4C, 0xAB, 0x6F, 0xD7, 0xBD, 0x37, 0x1D, 0x57,
0xC2, 0x16, 0x60, 0x95, 0x91, 0x0E, 0x4A, 0xD8,
0xE9, 0xED, 0x18, 0x1E, 0xF7, 0x61, 0x93, 0x61,
0x53, 0x89, 0x2D, 0x77, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x43, 0x41, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x81, 0x12, 0x2A, 0x46,
0xC9, 0xCC, 0x2D, 0xC4, 0xDF, 0x29, 0x30, 0xE4,
0xDF, 0x3F, 0x8C, 0x70, 0xA0, 0x78, 0x94, 0x87,
0x75, 0xAD, 0x5E, 0x9A, 0xA6, 0x04, 0xC5, 0xB4,
0xD8, 0xEA, 0xFF, 0x2A, 0xA1, 0xD2, 0x14, 0x67,
0x65, 0x64, 0xEF, 0xCA, 0x28, 0xCC, 0x00, 0x15,
0x45, 0x54, 0xA1, 0xA3, 0xEA, 0x13, 0x79, 0xE9,
0xE6, 0xCA, 0xAC, 0xED, 0x15, 0x93, 0xFE, 0x88,
0xD8, 0x9A, 0xC6, 0xB8, 0xAC, 0xCC, 0xAB, 0x6E,
0x20, 0x7C, 0xEB, 0x7C, 0xCA, 0x29, 0x80, 0x9E,
0x29, 0x80, 0x44, 0x06, 0x62, 0xB7, 0xD4, 0x38,
0x2A, 0x15, 0xDA, 0x43, 0x08, 0x57, 0x45, 0xA9,
0xAA, 0xE5, 0x9A, 0xA0, 0x5B, 0xDB, 0x32, 0xF6,
0x68, 0x69, 0xA2, 0xDD, 0x42, 0x95, 0x38, 0x6C,
0x87, 0xEC, 0xDD, 0x35, 0x08, 0xA2, 0xCF, 0x60,
0xD0, 0x1E, 0x23, 0xEC, 0x2F, 0xE6, 0x98, 0xF4,
0x70, 0xD6, 0x00, 0x15, 0x49, 0xA2, 0xF0, 0x67,
0x59, 0x13, 0x1E, 0x53, 0x4C, 0x70, 0x06, 0x05,
0x7D, 0xEF, 0x1D, 0x18, 0xA8, 0x3F, 0x0A, 0xC7,
0x9C, 0xFE, 0x80, 0xFF, 0x5A, 0x91, 0xF2, 0xBE,
0xD4, 0xA0, 0x83, 0x70, 0x61, 0x19, 0x0A, 0x03,
0x29, 0x90, 0x21, 0x65, 0x40, 0x3C, 0x9A, 0x90,
0x8F, 0xB6, 0x15, 0x73, 0x9F, 0x3C, 0xE3, 0x3B,
0xF1, 0xBA, 0xEA, 0x16, 0xC2, 0x5B, 0xCE, 0xD7,
0x96, 0x3F, 0xAC, 0xC9, 0xD2, 0x4D, 0x9C, 0x0A,
0xD7, 0x6F, 0xC0, 0x20, 0xB2, 0xC4, 0xB8, 0x4C,
0x10, 0xA7, 0x41, 0xA2, 0xCC, 0x7D, 0x9B, 0xAC,
0x3A, 0xAC, 0xCC, 0xA3, 0x52, 0x9B, 0xAC, 0x31,
0x6A, 0x9A, 0xA7, 0x5D, 0x2A, 0x26, 0xC7, 0xD7,
0xD2, 0x88, 0xCB, 0xA4, 0x66, 0xC5, 0xFE, 0x5F,
0x45, 0x4A, 0xE6, 0x79, 0x74, 0x4A, 0x90, 0xA1,
0x57, 0x72, 0xDB, 0x3B, 0x0E, 0x47, 0xA4, 0x9A,
0xF0, 0x31, 0xD1, 0x6D, 0xBE, 0xAB, 0x33, 0x2B,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const unsigned char xs9_dpki_cert[0x300] =
{
0x00, 0x01, 0x00, 0x04, 0x63, 0x80, 0x5A, 0x35,
0x1A, 0x43, 0x7B, 0xA2, 0x43, 0x19, 0xBB, 0x3A,
0x77, 0x7B, 0x7A, 0xF3, 0x5E, 0x72, 0x4B, 0x15,
0x0A, 0x06, 0x39, 0x6C, 0x5F, 0xEC, 0x38, 0x45,
0xB1, 0x88, 0x76, 0x26, 0x8D, 0x5E, 0xDA, 0xE6,
0x2F, 0x14, 0xBA, 0x02, 0xFA, 0xD6, 0xFC, 0x3B,
0x2B, 0xBE, 0x87, 0x07, 0x63, 0x8E, 0x55, 0xBF,
0x05, 0x5A, 0xFC, 0xFC, 0xB3, 0x47, 0x69, 0x11,
0x89, 0xDB, 0x1C, 0xAF, 0x4B, 0x43, 0x76, 0x62,
0x3E, 0x30, 0x89, 0x0A, 0x9D, 0x3B, 0xBB, 0x3E,
0x50, 0xBD, 0xF7, 0xA6, 0xC0, 0xF7, 0xF8, 0xBB,
0x0D, 0xB5, 0x6A, 0xBB, 0xC6, 0xC3, 0x50, 0xC8,
0x88, 0xBB, 0x9D, 0xF0, 0x9B, 0xD1, 0x30, 0x64,
0x60, 0x69, 0xDD, 0x34, 0x67, 0xA7, 0x00, 0xEB,
0xDC, 0xF9, 0x8C, 0xB0, 0xF7, 0x93, 0x0E, 0x81,
0xFE, 0x98, 0xD9, 0x72, 0x45, 0x8B, 0x94, 0x7E,
0x59, 0xE2, 0xBE, 0x4E, 0x91, 0x2D, 0x75, 0xCA,
0x1B, 0x8E, 0x2E, 0xF4, 0x6D, 0x73, 0xB1, 0x6B,
0x35, 0xB5, 0x67, 0x0D, 0x63, 0x2D, 0x51, 0x38,
0x53, 0x28, 0x19, 0x1D, 0x9D, 0xAE, 0x8D, 0xC6,
0x61, 0xCC, 0xEF, 0xA4, 0xAB, 0xE2, 0xF3, 0xB0,
0x4C, 0x7B, 0xE2, 0x71, 0xB5, 0xF9, 0x2C, 0xFA,
0x55, 0xCD, 0x88, 0x8B, 0x72, 0xCC, 0xBE, 0x67,
0xFA, 0xDF, 0xEF, 0x6B, 0x53, 0x3C, 0x45, 0xD8,
0xCB, 0xDF, 0xB2, 0x76, 0x41, 0x46, 0xD6, 0xC2,
0x6F, 0x27, 0x16, 0xC5, 0x07, 0xF3, 0xF4, 0x44,
0x66, 0xA3, 0x15, 0xD2, 0x77, 0xF2, 0x89, 0xDA,
0xFD, 0xD5, 0x50, 0xCF, 0xA4, 0x9B, 0xEA, 0xCA,
0xC9, 0x7B, 0xE5, 0x46, 0x0E, 0xED, 0x9B, 0xFB,
0x04, 0xA9, 0xDA, 0x19, 0x58, 0xD9, 0x2A, 0x20,
0x8A, 0xAC, 0xC1, 0xF4, 0x8E, 0xE9, 0x14, 0xD8,
0x8A, 0xD7, 0x41, 0xD5, 0x5B, 0x9B, 0x64, 0x22,
0xD8, 0xAF, 0xAE, 0xC7, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x2D, 0x43, 0x41, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x58, 0x53, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x39, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x18, 0xA3, 0x47, 0xA4,
0xC0, 0x84, 0x4C, 0xEB, 0x7E, 0xB0, 0xCF, 0xF0,
0xAE, 0xB7, 0x77, 0x69, 0x85, 0x93, 0xE4, 0x99,
0x5A, 0x95, 0x4E, 0x58, 0x17, 0x38, 0xCE, 0xD6,
0x81, 0xB0, 0xBD, 0x77, 0x09, 0xE7, 0xF8, 0x9A,
0xDF, 0xAD, 0x05, 0x48, 0x83, 0xF6, 0xC3, 0xFD,
0xDF, 0x7B, 0x83, 0xE0, 0x0C, 0x26, 0x81, 0x54,
0x43, 0x29, 0xEA, 0x82, 0x6C, 0x89, 0xF0, 0xA6,
0x74, 0x42, 0x86, 0x4D, 0x32, 0x60, 0x32, 0x7D,
0xA7, 0x7A, 0x13, 0x40, 0x66, 0x59, 0xDA, 0x3E,
0x41, 0x6B, 0x27, 0x94, 0x03, 0x4F, 0xAA, 0x22,
0x9D, 0xD5, 0x54, 0x52, 0xDB, 0x27, 0x0A, 0x6A,
0xA2, 0x3D, 0x19, 0xB1, 0x66, 0x1B, 0x19, 0x7D,
0xAB, 0xC7, 0x0E, 0x88, 0x17, 0x91, 0xA1, 0x2A,
0xB4, 0x3C, 0x6C, 0xCB, 0xF5, 0xAA, 0x7C, 0x3A,
0xDD, 0x36, 0xFB, 0x35, 0x71, 0x7B, 0x20, 0x01,
0x59, 0x00, 0xD6, 0xF6, 0x90, 0x39, 0x35, 0x41,
0x31, 0xF8, 0xC1, 0xC0, 0x57, 0x3A, 0x35, 0x18,
0x58, 0x90, 0xB1, 0xAD, 0x9A, 0x0E, 0xEC, 0xE0,
0xF4, 0x7A, 0x7D, 0xA5, 0x27, 0x48, 0xC9, 0x72,
0xAB, 0x0D, 0x08, 0x7B, 0x62, 0x35, 0x40, 0x91,
0x14, 0x2B, 0xB1, 0x1D, 0x1A, 0xFA, 0xF9, 0xCD,
0x5C, 0x17, 0x13, 0x53, 0x52, 0x71, 0xCA, 0xE2,
0x2A, 0x78, 0xB1, 0x7F, 0x4A, 0xCD, 0x59, 0xD8,
0xBA, 0x1D, 0x7D, 0x70, 0x5F, 0x78, 0x1B, 0x9F,
0x9D, 0x37, 0x18, 0x8E, 0xD7, 0xCD, 0x0D, 0x49,
0x57, 0x74, 0x69, 0x88, 0x3A, 0x6B, 0x8E, 0x4E,
0x1B, 0x85, 0xDD, 0xBE, 0x39, 0x45, 0x05, 0x89,
0x56, 0x12, 0x97, 0x59, 0x9A, 0x09, 0xA4, 0xC8,
0x2D, 0x2F, 0xF5, 0xCF, 0xB4, 0x73, 0x70, 0xDB,
0x58, 0x1E, 0xB2, 0x4E, 0x77, 0x6F, 0xA4, 0x7E,
0x62, 0xDF, 0xB7, 0x05, 0xE8, 0x80, 0x42, 0x5C,
0xB8, 0x78, 0x87, 0x97, 0x7F, 0x66, 0x2C, 0x5F,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const unsigned char cpA_dpki_cert[0x300] =
{
0x00, 0x01, 0x00, 0x04, 0x50, 0x05, 0xD7, 0x5E,
0x6D, 0xDE, 0xB8, 0x78, 0x3C, 0x81, 0xE9, 0xEF,
0x0D, 0x17, 0xCD, 0x58, 0xF5, 0x94, 0x26, 0xA3,
0xFD, 0x6F, 0x69, 0x90, 0xE8, 0xF8, 0x32, 0x87,
0x12, 0x2E, 0xC2, 0x5C, 0xA1, 0x4B, 0x99, 0x24,
0x23, 0x37, 0xBA, 0x91, 0xA7, 0x5B, 0x0F, 0x7C,
0x59, 0xFB, 0xF7, 0xD1, 0x89, 0x27, 0x22, 0xC4,
0xE6, 0xAF, 0xC7, 0xDE, 0xC7, 0x4A, 0x6E, 0x00,
0x7F, 0x43, 0x4A, 0x88, 0x8A, 0x82, 0x15, 0xE8,
0xDF, 0x2B, 0x52, 0xED, 0x42, 0x00, 0xBC, 0x69,
0xB4, 0xDA, 0x7F, 0xEB, 0x74, 0x6C, 0x7A, 0x2D,
0x96, 0x56, 0x5B, 0x45, 0x59, 0x7B, 0x8F, 0xAE,
0xB1, 0x6B, 0xDC, 0x76, 0xC1, 0xC8, 0x0C, 0x47,
0xF5, 0x0D, 0xA9, 0xC3, 0xE1, 0xFE, 0x28, 0x50,
0x1C, 0x26, 0xA2, 0xD1, 0x54, 0x4B, 0xD1, 0x60,
0x4A, 0x9E, 0x8F, 0x32, 0x2A, 0xEF, 0x31, 0x5F,
0xEA, 0x48, 0x22, 0x67, 0x22, 0xB7, 0xCB, 0x37,
0x2F, 0xF3, 0x5F, 0x5E, 0x61, 0x6A, 0x53, 0x44,
0xA5, 0x85, 0xE5, 0xA0, 0x8A, 0x2E, 0x17, 0x77,
0x57, 0x2B, 0x7A, 0x9A, 0xF7, 0xD2, 0xD8, 0xC4,
0x9C, 0xD0, 0xA0, 0x54, 0xBF, 0x8A, 0x9D, 0xB4,
0x9F, 0xC6, 0x60, 0x61, 0x7C, 0xB8, 0x35, 0x4E,
0x25, 0x7F, 0x68, 0x68, 0x2F, 0x94, 0xB3, 0xCC,
0x53, 0x8C, 0x42, 0x6F, 0x88, 0xC5, 0x48, 0x5C,
0xBE, 0xC1, 0xD0, 0x48, 0x04, 0x74, 0x96, 0x5A,
0x7E, 0x82, 0x59, 0xAA, 0x9F, 0xB6, 0x61, 0x46,
0xCE, 0x59, 0x21, 0xC6, 0xF0, 0xC1, 0x75, 0x1F,
0x21, 0x91, 0x7F, 0x24, 0x96, 0xCB, 0x0C, 0x70,
0x15, 0x7A, 0xB7, 0xBB, 0x3A, 0x9F, 0x57, 0x56,
0x56, 0x5C, 0x38, 0x92, 0x2E, 0xFD, 0xC8, 0xF1,
0x70, 0xB9, 0xAE, 0xA1, 0xAE, 0x36, 0xF5, 0x5E,
0x35, 0x26, 0x63, 0x0A, 0xBA, 0xB2, 0x05, 0x0F,
0xF0, 0x0C, 0xDC, 0xBB, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x52, 0x6F, 0x6F, 0x74, 0x2D, 0x43, 0x41, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x43, 0x50, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x61, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x18, 0xA3, 0x4D, 0x5B,
0xAA, 0x7F, 0x93, 0x80, 0x28, 0x9B, 0xE8, 0x98,
0x63, 0x10, 0x7A, 0xE1, 0x0C, 0x59, 0x2C, 0x2F,
0x7C, 0xFF, 0xBD, 0xAA, 0xDD, 0x74, 0xF4, 0xA2,
0xFB, 0xAC, 0xD7, 0x6F, 0x00, 0x93, 0x42, 0x06,
0x34, 0x71, 0x56, 0xD8, 0x40, 0x49, 0x72, 0x9F,
0x3E, 0x24, 0xFA, 0x5E, 0x19, 0xD1, 0x5B, 0x63,
0x5C, 0xD2, 0xEF, 0x09, 0xDE, 0x32, 0xEE, 0x6B,
0x6F, 0xC8, 0xFA, 0x32, 0x8E, 0x2E, 0x96, 0xB9,
0x94, 0x41, 0x04, 0x7D, 0x07, 0x62, 0x95, 0xDA,
0x0D, 0x91, 0xD8, 0x09, 0x35, 0xD0, 0xDE, 0x8E,
0x6B, 0xC6, 0xAB, 0x14, 0x27, 0x01, 0x9C, 0xFE,
0x49, 0x96, 0xFC, 0x9B, 0x54, 0x79, 0x4D, 0xEB,
0xD7, 0xC6, 0x66, 0x73, 0xA6, 0xDD, 0x3A, 0x77,
0x65, 0x47, 0x94, 0xEC, 0x1C, 0x87, 0xAA, 0x46,
0xD9, 0x78, 0xA9, 0x7D, 0xDB, 0x11, 0x22, 0x6E,
0xD4, 0x12, 0xC2, 0x78, 0x4B, 0x21, 0x83, 0x92,
0xC7, 0x10, 0xC7, 0x74, 0x19, 0xFF, 0xAA, 0xF6,
0x0B, 0x75, 0xD8, 0x23, 0xDD, 0x33, 0xC3, 0xA1,
0x5B, 0xA7, 0x2D, 0x30, 0xA5, 0xA4, 0xD8, 0xF8,
0x0F, 0xD6, 0x73, 0xFD, 0x26, 0xCB, 0x29, 0xA6,
0xEF, 0x50, 0x39, 0xE2, 0x5F, 0x59, 0x61, 0x84,
0x6B, 0xDA, 0x2E, 0xC7, 0xCB, 0xE4, 0x38, 0x4B,
0x28, 0xFB, 0x0D, 0xD5, 0x8E, 0x7C, 0xAA, 0x7D,
0x4B, 0x37, 0x3A, 0xD7, 0x81, 0xDD, 0x73, 0xE3,
0x09, 0x93, 0xBD, 0xBD, 0x7E, 0x08, 0x55, 0x4A,
0x8C, 0xA5, 0xC9, 0x84, 0x2D, 0x71, 0x01, 0xA2,
0x2A, 0x01, 0xB0, 0x15, 0xFB, 0x30, 0x78, 0xB9,
0x13, 0xF4, 0xC7, 0x3F, 0xB5, 0xA6, 0xF1, 0xA2,
0x5E, 0x22, 0xB0, 0x02, 0xB6, 0xE0, 0x09, 0x54,
0x7F, 0x0F, 0xBD, 0xF0, 0xFE, 0xA5, 0x50, 0x1D,
0x93, 0x15, 0xF9, 0x3D, 0x83, 0x0F, 0x0F, 0x0E,
0x3D, 0xE2, 0x3D, 0x96, 0xE7, 0x09, 0xD9, 0x77,
0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif
elf.c
+25 -2
View File
@@ -70,11 +70,17 @@ int BuildExeFsCode(ncch_settings *ncchset)
return result;
}
#ifdef DEBUG
printf("[DEBUG] Import ELF\n");
#endif
/* Import ELF */
u8 *ElfFile = malloc(ncchset->ComponentFilePtrs.elf_size);
if(!ElfFile) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ElfFile,ncchset->ComponentFilePtrs.elf_size,0,ncchset->ComponentFilePtrs.elf);
#ifdef DEBUG
printf("[DEBUG] Create ELF Context\n");
#endif
/* Create ELF Context */
ElfContext *elf = malloc(sizeof(ElfContext));
if(!elf) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); free(ElfFile); return MEM_ERROR;}
@@ -95,9 +101,18 @@ int BuildExeFsCode(ncch_settings *ncchset)
PrintElfContext(elf,ElfFile);
#endif
#ifdef DEBUG
PrintElfContext(elf,ElfFile);
#endif
#ifdef DEBUG
printf("[DEBUG] Create ExeFs Code\n");
#endif
result = CreateExeFsCode(elf,ElfFile,ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Get BSS Size\n");
#endif
result = GetBSS_SizeFromElf(elf,ElfFile,ncchset);
if(result) goto finish;
@@ -110,10 +125,18 @@ finish:
else if(result == NOT_FIND_CODE_SECTIONS) fprintf(stderr,"[ELF ERROR] Failed to retrieve code sections from ELF\n");
else fprintf(stderr,"[ELF ERROR] Failed to process ELF file (%d)\n",result);
}
#ifdef DEBUG
printf("[DEBUG] Free Segment Header/Sections\n");
#endif
for(int i = 0; i < elf->ActiveSegments; i++){
free(elf->Segments[i].Header);
#ifdef DEBUG
printf("[DEBUG] %d\n",i);
#endif
free(elf->Segments[i].Sections);
}
#ifdef DEBUG
printf("[DEBUG] Free others\n");
#endif
free(ElfFile);
free(elf->Sections);
free(elf->ProgramHeaders);
exheader.c
+350 -197
View File
@@ -5,9 +5,7 @@
#include "titleid.h"
#include "polarssl/base64.h"
#ifndef RETAIL_FSIGN
#include "accessdesc_sig.h" // For AccessDesc Presets
#endif
/* Prototypes */
void init_ExHeaderSettings(exheader_settings *exhdrset);
@@ -15,11 +13,10 @@ void free_ExHeaderSettings(exheader_settings *exhdrset);
int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *ncchset);
int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset);
void AdjustBooleans(rsf_settings *yaml);
int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *yaml);
int get_ExHeaderDependencyList(u8 *DependencyList, rsf_settings *yaml);
int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, rsf_settings *yaml);
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml);
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml, bool UseAccessDescPreset);
int SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml);
int GetAppType(int *AppType, rsf_settings *yaml);
int SetARM11ResLimitDesc(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml);
@@ -56,6 +53,9 @@ u32 GetDescPrefixMask(int numPrefixBits);
u32 GetDescPrefixBits(int numPrefixBits, u32 PrefixVal);
int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_settings *yaml);
int set_AccessDesc(exheader_settings *exhdrset, ncch_settings *ncchset);
int accessdesc_SignWithKey(exheader_settings *exhdrset, ncch_settings *ncchset);
int accessdesc_GetSignFromRsf(exheader_settings *exhdrset, ncch_settings *ncchset);
int accessdesc_GetSignFromPreset(exheader_settings *exhdrset, ncch_settings *ncchset);
/* ExHeader Signature Functions */
int SignAccessDesc(ExtendedHeader_Struct *ExHdr, keys_struct *keys)
@@ -90,6 +90,9 @@ int BuildExHeader(ncch_settings *ncchset)
result = set_AccessDesc(exhdrset,ncchset);
if(result) goto finish;
exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities.Flags[6] = 5;
finish:
if(result) fprintf(stderr,"[EXHEADER ERROR] Failed to create ExHeader\n");
free_ExHeaderSettings(exhdrset);
@@ -112,6 +115,7 @@ int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *
/* Transfer settings */
exhdrset->keys = ncchset->keys;
exhdrset->yaml = ncchset->yaml_set;
exhdrset->UseAccessDescPreset = ncchset->keys->AccessDescSign.PresetType != not_preset;
/* Creating Output Buffer */
ncchset->Sections.ExHeader.size = 0x800;
@@ -119,10 +123,14 @@ int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *
if(!ncchset->Sections.ExHeader.buffer) {fprintf(stderr,"[EXHEADER ERROR] MEM ERROR\n"); return MEM_ERROR;}
memset(ncchset->Sections.ExHeader.buffer,0,ncchset->Sections.ExHeader.size);
/* Import ExHeader template */
/* Import ExHeader Code Section template */
if(ncchset->ComponentFilePtrs.exheader_size){
u32 import_size = min_u64(0x40,ncchset->ComponentFilePtrs.exheader_size);
ReadFile_64(ncchset->Sections.ExHeader.buffer,import_size,0,ncchset->ComponentFilePtrs.exheader);
u32 import_size = 0x30; min_u64(0x30,ncchset->ComponentFilePtrs.exheader_size);
u32 import_offset = 0x10;
if((import_size+import_offset) > ncchset->ComponentFilePtrs.exheader_size){
fprintf(stderr,"[EXHEADER ERROR] Exheader Template is too small\n");
}
ReadFile_64((ncchset->Sections.ExHeader.buffer+import_offset),import_size,import_offset,ncchset->ComponentFilePtrs.exheader);
}
/* Create ExHeader Struct for output */
@@ -152,54 +160,40 @@ int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *
if(ncchset->Options.UseOnSD)
exhdrset->ExHdr->CodeSetInfo.Flags.flag |= RetailSDAppFlag;
if(!ncchset->Options.UseRomFS) // Move this later
exhdrset->ExHdr->ARM11SystemLocalCapabilities.StorageInfo.OtherAttributes |= 1 << NOT_USE_ROMFS;
exhdrset->ExHdr->ARM11SystemLocalCapabilities.StorageInfo.OtherAttributes |= 1 << attribute_NOT_USE_ROMFS;
return 0;
}
int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset)
{
AdjustBooleans(exhdrset->yaml);
int result = 0;
result = get_ExHeaderCodeSetInfo(&exhdrset->ExHdr->CodeSetInfo, exhdrset->yaml);
if(result) goto finish;
result = get_ExHeaderDependencyList((u8*)&exhdrset->ExHdr->DependencyList[0], exhdrset->yaml);
if(result) goto finish;
if(!exhdrset->UseAccessDescPreset){
result = get_ExHeaderDependencyList((u8*)&exhdrset->ExHdr->DependencyList[0], exhdrset->yaml);
if(result) goto finish;
}
result = get_ExHeaderSystemInfo(&exhdrset->ExHdr->SystemInfo, exhdrset->yaml);
if(result) goto finish;
result = get_ExHeaderARM11SystemLocalInfo(&exhdrset->ExHdr->ARM11SystemLocalCapabilities, exhdrset->yaml);
result = get_ExHeaderARM11SystemLocalInfo(&exhdrset->ExHdr->ARM11SystemLocalCapabilities, exhdrset->yaml, exhdrset->UseAccessDescPreset);
if(result) goto finish;
result = get_ExHeaderARM11KernelInfo(&exhdrset->ExHdr->ARM11KernelCapabilities, exhdrset->yaml);
if(result) goto finish;
if(!exhdrset->UseAccessDescPreset){
result = get_ExHeaderARM11KernelInfo(&exhdrset->ExHdr->ARM11KernelCapabilities, exhdrset->yaml);
if(result) goto finish;
result = get_ExHeaderARM9AccessControlInfo(&exhdrset->ExHdr->ARM9AccessControlInfo, exhdrset->yaml);
if(result) goto finish;
result = get_ExHeaderARM9AccessControlInfo(&exhdrset->ExHdr->ARM9AccessControlInfo, exhdrset->yaml);
if(result) goto finish;
}
finish:
return result;
}
void AdjustBooleans(rsf_settings *yaml)
{
if(yaml->AccessControlInfo.DisableDebug == -1) yaml->AccessControlInfo.DisableDebug = 0;
if(yaml->AccessControlInfo.EnableForceDebug == -1) yaml->AccessControlInfo.EnableForceDebug = 0;
if(yaml->AccessControlInfo.CanWriteSharedPage == -1) yaml->AccessControlInfo.CanWriteSharedPage = 0;
if(yaml->AccessControlInfo.CanUsePrivilegedPriority == -1) yaml->AccessControlInfo.CanUsePrivilegedPriority = 0;
if(yaml->AccessControlInfo.CanUseNonAlphabetAndNumber == -1) yaml->AccessControlInfo.CanUseNonAlphabetAndNumber = 0;
if(yaml->AccessControlInfo.PermitMainFunctionArgument == -1) yaml->AccessControlInfo.PermitMainFunctionArgument = 0;
if(yaml->AccessControlInfo.CanShareDeviceMemory == -1) yaml->AccessControlInfo.CanShareDeviceMemory = 0;
if(yaml->AccessControlInfo.UseOtherVariationSaveData == -1) yaml->AccessControlInfo.UseOtherVariationSaveData = 0;
if(yaml->AccessControlInfo.UseExtSaveData == -1) yaml->AccessControlInfo.UseExtSaveData = 0;
if(yaml->AccessControlInfo.UseExtendedSaveDataAccessControl == -1) yaml->AccessControlInfo.UseExtendedSaveDataAccessControl = 0;
if(yaml->AccessControlInfo.RunnableOnSleep == -1) yaml->AccessControlInfo.RunnableOnSleep = 0;
if(yaml->AccessControlInfo.SpecialMemoryArrange == -1) yaml->AccessControlInfo.SpecialMemoryArrange = 0;
}
int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *yaml)
{
/* Name */
@@ -256,19 +250,19 @@ int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, rsf_settings *yaml)
if(strstr(yaml->Rom.SaveDataSize,"K")){
char *str = strstr(yaml->Rom.SaveDataSize,"K");
if(strcmp(str,"K") == 0 || strcmp(str,"KB") == 0 ){
SaveDataSize = SaveDataSize*KB;
SaveDataSize *= KB;
}
}
else if(strstr(yaml->Rom.SaveDataSize,"M")){
char *str = strstr(yaml->Rom.SaveDataSize,"M");
if(strcmp(str,"M") == 0 || strcmp(str,"MB") == 0 ){
SaveDataSize = SaveDataSize*MB;
SaveDataSize *= MB;
}
}
else if(strstr(yaml->Rom.SaveDataSize,"G")){
char *str = strstr(yaml->Rom.SaveDataSize,"G");
if(strcmp(str,"G") == 0 || strcmp(str,"GB") == 0 ){
SaveDataSize = SaveDataSize*GB;
SaveDataSize *= GB;
}
}
else{
@@ -298,7 +292,7 @@ int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, rsf_settings *yaml)
return 0;
}
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml)
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml, bool UseAccessDescPreset)
{
/* Program Id */
u64 ProgramId = 0;
@@ -306,30 +300,33 @@ int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11,
if(result) return result;
u64_to_u8(arm11->ProgramId,ProgramId,LE);
/* Flags */
result = SetARM11SystemLocalInfoFlags(arm11, yaml);
if(result) return result;
if(!UseAccessDescPreset){
/* Flags */
result = SetARM11SystemLocalInfoFlags(arm11, yaml);
if(result) return result;
/* Resource Limit Descriptors */
result = SetARM11ResLimitDesc(arm11, yaml);
if(result) return result;
/* Resource Limit Descriptors */
result = SetARM11ResLimitDesc(arm11, yaml);
if(result) return result;
}
/* Storage Info */
result = SetARM11StorageInfo(arm11, yaml);
if(result) return result;
/* Service Access Control */
result = SetARM11ServiceAccessControl(arm11, yaml);
if(result) return result;
if(!UseAccessDescPreset){
/* Service Access Control */
result = SetARM11ServiceAccessControl(arm11, yaml);
if(result) return result;
/* Resource Limit Category */
if(yaml->AccessControlInfo.ResourceLimitCategory){
if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"application") == 0) arm11->ResourceLimitCategory = resrc_limit_APPLICATION;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"sysapplet") == 0) arm11->ResourceLimitCategory = resrc_limit_SYS_APPLET;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"libapplet") == 0) arm11->ResourceLimitCategory = resrc_limit_LIB_APPLET;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"other") == 0) arm11->ResourceLimitCategory = resrc_limit_OTHER;
/* Resource Limit Category */
if(yaml->AccessControlInfo.ResourceLimitCategory){
if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"application") == 0) arm11->ResourceLimitCategory = resrc_limit_APPLICATION;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"sysapplet") == 0) arm11->ResourceLimitCategory = resrc_limit_SYS_APPLET;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"libapplet") == 0) arm11->ResourceLimitCategory = resrc_limit_LIB_APPLET;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"other") == 0) arm11->ResourceLimitCategory = resrc_limit_OTHER;
}
}
/* Finish */
return 0;
}
@@ -352,14 +349,14 @@ int SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_
u8 SystemMode = 0;
if(yaml->AccessControlInfo.AffinityMask){
AffinityMask = strtol(yaml->AccessControlInfo.AffinityMask,NULL,0);
if(AffinityMask != 0 && AffinityMask != 1){
if(AffinityMask > 1){
fprintf(stderr,"[EXHEADER ERROR] Unexpected AffinityMask: %d. Expected range: 0x0 - 0x1\n",AffinityMask);
return EXHDR_BAD_YAML_OPT;
}
}
if(yaml->AccessControlInfo.IdealProcessor){
IdealProcessor = strtol(yaml->AccessControlInfo.IdealProcessor,NULL,0);
if(IdealProcessor != 0 && IdealProcessor != 1){
if(IdealProcessor > 1){
fprintf(stderr,"[EXHEADER ERROR] Unexpected IdealProcessor: %d. Expected range: 0x0 - 0x1\n",IdealProcessor);
return EXHDR_BAD_YAML_OPT;
}
@@ -443,47 +440,47 @@ int SetARM11StorageInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings
u32 AccessInfo = 0;
for(int i = 0; i < yaml->AccessControlInfo.FileSystemAccessNum; i++){
if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategorySystemApplication") == 0)
AccessInfo |= 1 << CATEGORY_SYSTEM_APPLICATION;
AccessInfo |= 1 << fsaccess_CATEGORY_SYSTEM_APPLICATION;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategoryHardwareCheck") == 0)
AccessInfo |= 1 << CATEGORY_HARDWARE_CHECK;
AccessInfo |= 1 << fsaccess_CATEGORY_HARDWARE_CHECK;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategoryFileSystemTool") == 0)
AccessInfo |= 1 << CATEGORY_FILE_SYSTEM_TOOL;
AccessInfo |= 1 << fsaccess_CATEGORY_FILE_SYSTEM_TOOL;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"Debug") == 0)
AccessInfo |= 1 << DEBUG;
AccessInfo |= 1 << fsaccess_DEBUG;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"TwlCardBackup") == 0)
AccessInfo |= 1 << TWL_CARD_BACKUP;
AccessInfo |= 1 << fsaccess_TWL_CARD_BACKUP;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"TwlNandData") == 0)
AccessInfo |= 1 << TWL_NAND_DATA;
AccessInfo |= 1 << fsaccess_TWL_NAND_DATA;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"Boss") == 0)
AccessInfo |= 1 << BOSS;
AccessInfo |= 1 << fsaccess_BOSS;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0)
AccessInfo |= 1 << DIRECT_SDMC;
AccessInfo |= 1 << fsaccess_DIRECT_SDMC;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"Core") == 0)
AccessInfo |= 1 << CORE;
AccessInfo |= 1 << fsaccess_CORE;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CtrNandRo") == 0)
AccessInfo |= 1 << CTR_NAND_RO;
AccessInfo |= 1 << fsaccess_CTR_NAND_RO;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CtrNandRw") == 0)
AccessInfo |= 1 << CTR_NAND_RW;
AccessInfo |= 1 << fsaccess_CTR_NAND_RW;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CtrNandRoWrite") == 0)
AccessInfo |= 1 << CTR_NAND_RO_WRITE;
AccessInfo |= 1 << fsaccess_CTR_NAND_RO_WRITE;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategorySystemSettings") == 0)
AccessInfo |= 1 << CATEGORY_SYSTEM_SETTINGS;
AccessInfo |= 1 << fsaccess_CATEGORY_SYSTEM_SETTINGS;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CardBoard") == 0)
AccessInfo |= 1 << CARD_BOARD;
AccessInfo |= 1 << fsaccess_CARD_BOARD;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"ExportImportIvs") == 0)
AccessInfo |= 1 << EXPORT_IMPORT_IVS;
AccessInfo |= 1 << fsaccess_EXPORT_IMPORT_IVS;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"DirectSdmcWrite") == 0)
AccessInfo |= 1 << DIRECT_SDMC_WRITE;
AccessInfo |= 1 << fsaccess_DIRECT_SDMC_WRITE;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"SwitchCleanup") == 0)
AccessInfo |= 1 << SWITCH_CLEANUP;
AccessInfo |= 1 << fsaccess_SWITCH_CLEANUP;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"SaveDataMove") == 0)
AccessInfo |= 1 << SAVE_DATA_MOVE;
AccessInfo |= 1 << fsaccess_SAVE_DATA_MOVE;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"Shop") == 0)
AccessInfo |= 1 << SHOP;
AccessInfo |= 1 << fsaccess_SHOP;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"Shell") == 0)
AccessInfo |= 1 << SHELL;
AccessInfo |= 1 << fsaccess_SHELL;
else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategoryHomeMenu") == 0)
AccessInfo |= 1 << CATEGORY_HOME_MENU;
AccessInfo |= 1 << fsaccess_CATEGORY_HOME_MENU;
else{
fprintf(stderr,"[EXHEADER ERROR] Invalid FileSystemAccess Name: '%s'\n",yaml->AccessControlInfo.FileSystemAccess[i]);
return EXHDR_BAD_YAML_OPT;
@@ -513,8 +510,8 @@ int SetARM11StorageInfoExtSaveDataId(exhdr_ARM11SystemLocalCapabilities *arm11,
fprintf(stderr,"[EXHEADER ERROR] Failed to set ExtSaveDataId. UseExtSaveData must be true.\n");
return EXHDR_BAD_YAML_OPT;
}
u32 ExtdataIdLow = strtoul(yaml->AccessControlInfo.ExtSaveDataId,NULL,0);
u32_to_u8(arm11->StorageInfo.ExtSaveDataId,ExtdataIdLow,LE);
u64 ExtdataId = strtoull(yaml->AccessControlInfo.ExtSaveDataId,NULL,0);
u64_to_u8(arm11->StorageInfo.ExtSaveDataId,ExtdataId,LE);
}
return 0;
}
@@ -547,6 +544,13 @@ bool CheckCondiditionsForNewAccessibleSaveDataIds(rsf_settings *yaml)
return false;
}
/*
if(yaml->AccessControlInfo.AccessibleSaveDataIdsNum == 0){
fprintf(stderr,"[EXHEADER ERROR] AccessibleSaveDataIds must be specified if UseExtendedSaveDataAccessControl is true.\n");
return false;
}
*/
if(yaml->AccessControlInfo.AccessibleSaveDataIdsNum > 6){
fprintf(stderr,"[EXHEADER ERROR] Too many UniqueId in \"AccessibleSaveDataIds\".\n");
return false;
@@ -602,7 +606,7 @@ int SetARM11StorageInfoAccessibleSaveDataIds(exhdr_ARM11SystemLocalCapabilities
}
}
arm11->StorageInfo.OtherAttributes |= 1 << USE_EXTENDED_SAVEDATA_ACCESS_CONTROL;
arm11->StorageInfo.OtherAttributes |= 1 << attribute_USE_EXTENDED_SAVEDATA_ACCESS_CONTROL;
/* UseOtherVariationSaveData Flag */
if(yaml->AccessControlInfo.UseOtherVariationSaveData){
@@ -618,20 +622,20 @@ int SetARM11ServiceAccessControl(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_
{
if(yaml->AccessControlInfo.ServiceAccessControl){
if(yaml->AccessControlInfo.ServiceAccessControlNum > 32){
fprintf(stderr,"[EXHEADER ERROR] Too Many SVC Handles, maximum is 32\n");
fprintf(stderr,"[EXHEADER ERROR] Too Many Service Names, maximum is 32\n");
return EXHDR_BAD_YAML_OPT;
}
for(int i = 0; i < yaml->AccessControlInfo.ServiceAccessControlNum; i++){
int svc_handle_len = strlen(yaml->AccessControlInfo.ServiceAccessControl[i]);
if(svc_handle_len > 8){
fprintf(stderr,"[EXHEADER ERROR] SVC Handle: '%s' is too long\n",yaml->AccessControlInfo.ServiceAccessControl[i]);
fprintf(stderr,"[EXHEADER ERROR] Service Name: \"%s\" is too long\n",yaml->AccessControlInfo.ServiceAccessControl[i]);
return EXHDR_BAD_YAML_OPT;
}
memcpy(arm11->ServiceAccessControl[i],yaml->AccessControlInfo.ServiceAccessControl[i],svc_handle_len);
}
}
else{
fprintf(stderr,"[EXHEADER ERROR] Parameter Not Found: 'AccessControlInfo/ServiceAccessControl'\n");
fprintf(stderr,"[EXHEADER ERROR] Parameter Not Found: \"AccessControlInfo/ServiceAccessControl\"\n");
return EXHDR_BAD_YAML_OPT;
}
return 0;
@@ -866,14 +870,17 @@ int GetARM11IOMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *yaml
u16 DescUsed = 0;
for(int i = 0; i < yaml->AccessControlInfo.IORegisterMappingNum; i++){
if(strlen(yaml->AccessControlInfo.IORegisterMapping[i])){
// Parse Address String
char *AddressStartStr = yaml->AccessControlInfo.IORegisterMapping[i];
char *AddressEndStr = strstr(AddressStartStr,"-");
if(AddressEndStr){
if(strlen(AddressEndStr) > 1)
AddressEndStr = (AddressEndStr+1);
if(strlen(AddressEndStr) > 1) // if not just '-'
AddressEndStr = (AddressEndStr+1); // Setting the str to the expected start of address string
else
AddressEndStr = NULL;
}
u32 AddressStart = strtoul(AddressStartStr,NULL,16);
if(!IsStartAddress(AddressStart)){
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x is not valid mapping start address.\n",AddressStart);
@@ -979,12 +986,12 @@ int GetARM11StaticMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *
bool IsEndAddress(u32 Address)
{
return (Address & 0xfff) == 0xfff;
return (Address & 0x0fff) == 0x0fff;
}
bool IsStartAddress(u32 Address)
{
return (Address & 0xfff) == 0;
return (Address & 0x0fff) == 0;
}
u32 GetIOMappingDesc(u32 Address)
@@ -1012,23 +1019,23 @@ int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, r
u32 OtherCapabilities = 0;
if(!yaml->AccessControlInfo.DisableDebug)
OtherCapabilities |= 1 << PERMIT_DEBUG;
OtherCapabilities |= 1 << othcap_PERMIT_DEBUG;
if(yaml->AccessControlInfo.EnableForceDebug)
OtherCapabilities |= 1 << FORCE_DEBUG;
OtherCapabilities |= 1 << othcap_FORCE_DEBUG;
if(yaml->AccessControlInfo.CanUseNonAlphabetAndNumber)
OtherCapabilities |= 1 << CAN_USE_NON_ALPHABET_AND_NUMBER;
OtherCapabilities |= 1 << othcap_CAN_USE_NON_ALPHABET_AND_NUMBER;
if(yaml->AccessControlInfo.CanWriteSharedPage)
OtherCapabilities |= 1 << CAN_WRITE_SHARED_PAGE;
OtherCapabilities |= 1 << othcap_CAN_WRITE_SHARED_PAGE;
if(yaml->AccessControlInfo.CanUsePrivilegedPriority)
OtherCapabilities |= 1 << CAN_USE_PRIVILEGE_PRIORITY;
OtherCapabilities |= 1 << othcap_CAN_USE_PRIVILEGE_PRIORITY;
if(yaml->AccessControlInfo.PermitMainFunctionArgument)
OtherCapabilities |= 1 << PERMIT_MAIN_FUNCTION_ARGUMENT;
OtherCapabilities |= 1 << othcap_PERMIT_MAIN_FUNCTION_ARGUMENT;
if(yaml->AccessControlInfo.CanShareDeviceMemory)
OtherCapabilities |= 1 << CAN_SHARE_DEVICE_MEMORY;
OtherCapabilities |= 1 << othcap_CAN_SHARE_DEVICE_MEMORY;
if(yaml->AccessControlInfo.RunnableOnSleep)
OtherCapabilities |= 1 << RUNNABLE_ON_SLEEP;
OtherCapabilities |= 1 << othcap_RUNNABLE_ON_SLEEP;
if(yaml->AccessControlInfo.SpecialMemoryArrange)
OtherCapabilities |= 1 << SPECIAL_MEMORY_ARRANGE;
OtherCapabilities |= 1 << othcap_SPECIAL_MEMORY_ARRANGE;
if(yaml->AccessControlInfo.MemoryType){
u32 MemType = 0;
@@ -1042,7 +1049,7 @@ int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, r
fprintf(stderr,"[EXHEADER ERROR] Invalid memory type: '%s'\n",yaml->AccessControlInfo.MemoryType);
return EXHDR_BAD_YAML_OPT;
}
OtherCapabilities = (OtherCapabilities & -3841) | MemType << 8;
OtherCapabilities = (OtherCapabilities & 0xffffff0f) | MemType << 8;
}
if(OtherCapabilities){
@@ -1123,21 +1130,21 @@ int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_set
u32 Arm9AccessControl = 0;
for(int i = 0; i < yaml->AccessControlInfo.IoAccessControlNum; i++){
if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountNand") == 0)
Arm9AccessControl |= 1 << FS_MOUNT_NAND;
Arm9AccessControl |= 1 << arm9cap_FS_MOUNT_NAND;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountNandRoWrite") == 0)
Arm9AccessControl |= 1 << FS_MOUNT_NAND_RO_WRITE;
Arm9AccessControl |= 1 << arm9cap_FS_MOUNT_NAND_RO_WRITE;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountTwln") == 0)
Arm9AccessControl |= 1 << FS_MOUNT_TWLN;
Arm9AccessControl |= 1 << arm9cap_FS_MOUNT_TWLN;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountWnand") == 0)
Arm9AccessControl |= 1 << FS_MOUNT_WNAND;
Arm9AccessControl |= 1 << arm9cap_FS_MOUNT_WNAND;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountCardSpi") == 0)
Arm9AccessControl |= 1 << FS_MOUNT_CARD_SPI;
Arm9AccessControl |= 1 << arm9cap_FS_MOUNT_CARD_SPI;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"UseSdif3") == 0)
Arm9AccessControl |= 1 << USE_SDIF3;
Arm9AccessControl |= 1 << arm9cap_USE_SDIF3;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"CreateSeed") == 0)
Arm9AccessControl |= 1 << CREATE_SEED;
Arm9AccessControl |= 1 << arm9cap_CREATE_SEED;
else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"UseCardSpi") == 0)
Arm9AccessControl |= 1 << USE_CARD_SPI;
Arm9AccessControl |= 1 << arm9cap_USE_CARD_SPI;
else{
fprintf(stderr,"[EXHEADER ERROR] Invalid IoAccessControl Name: '%s'\n",yaml->AccessControlInfo.IoAccessControl[i]);
return EXHDR_BAD_YAML_OPT;
@@ -1146,11 +1153,11 @@ int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_set
for(int i = 0; i < yaml->AccessControlInfo.FileSystemAccessNum; i++){
if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0)
Arm9AccessControl |= 1 << USE_DIRECT_SDMC;
Arm9AccessControl |= 1 << arm9cap_USE_DIRECT_SDMC;
}
if(yaml->Option.UseOnSD)
Arm9AccessControl |= 1 << SD_APPLICATION;
Arm9AccessControl |= 1 << arm9cap_SD_APPLICATION;
u32_to_u8(arm9->descriptors,Arm9AccessControl,LE);
@@ -1169,98 +1176,244 @@ int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_set
int set_AccessDesc(exheader_settings *exhdrset, ncch_settings *ncchset)
{
switch(ncchset->Options.accessdesc){
case auto_gen :
/* Set RSA Keys */
memcpy(ncchset->CxiRsaKey.PrivK,exhdrset->keys->rsa.CFA_Priv,0x100);
memcpy(ncchset->CxiRsaKey.PubK,exhdrset->keys->rsa.CFA_Pub,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,exhdrset->keys->rsa.CFA_Pub,0x100);
/* Copy Data From ExHeader */
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,&exhdrset->ExHdr->ARM11SystemLocalCapabilities,sizeof(exhdr_ARM11SystemLocalCapabilities));
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11KernelCapabilities,&exhdrset->ExHdr->ARM11KernelCapabilities,sizeof(exhdr_ARM11KernelCapabilities));
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM9AccessControlInfo,&exhdrset->ExHdr->ARM9AccessControlInfo,sizeof(exhdr_ARM9AccessControlInfo));
/* Sign AccessDesc */
return SignAccessDesc(exhdrset->ExHdr,exhdrset->keys);
case use_spec_file:
/* Yaml Option Sanity Checks */
if(!exhdrset->yaml->CommonHeaderKey.Found){
fprintf(stderr,"[EXHEADER ERROR] RSF Section 'CommonHeaderKey' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.D){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/D' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.D) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/D' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.D));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.Modulus){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Modulus' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.Modulus) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Modulus' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.Modulus));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.AccCtlDescSign){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Signature' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Signature' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.AccCtlDescBin){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Descriptor' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin) != 695){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Descriptor' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin));
return COMMON_HEADER_KEY_NOT_FOUND;
}
/* Set RSA Keys */
int result = 0;
u32 out = 0x500;
u8 *tmp = malloc(0x500);
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.Modulus,strlen(exhdrset->yaml->CommonHeaderKey.Modulus));
if(result) goto finish;
memcpy(ncchset->CxiRsaKey.PubK,tmp,0x100);
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.D,strlen(exhdrset->yaml->CommonHeaderKey.D));
if(result) goto finish;
memcpy(ncchset->CxiRsaKey.PrivK,tmp,0x100);
/* Set AccessDesc */
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.AccCtlDescSign,strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign));
if(result) goto finish;
memcpy(exhdrset->ExHdr->AccessDescriptor.signature,tmp,0x100);
memcpy(exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,ncchset->CxiRsaKey.PubK,0x100);
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.AccCtlDescBin,strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin));
if(result) goto finish;
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,tmp,0x200);
finish:
free(tmp);
return result;
#ifndef RETAIL_FSIGN
case app :
memcpy(ncchset->CxiRsaKey.PrivK,(u8*)App_sdk5_HdrPrivK,0x100);
memcpy(ncchset->CxiRsaKey.PubK,(u8*)App_sdk5_HdrPubK,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.signature,(u8*)App_sdk5_AcexData,0x400);
return 0;
case demo :
memcpy(ncchset->CxiRsaKey.PrivK,(u8*)Demo_sdk5_HdrPrivK,0x100);
memcpy(ncchset->CxiRsaKey.PubK,(u8*)Demo_sdk5_HdrPubK,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.signature,(u8*)Demo_sdk5_AcexData,0x400);
return 0;
case dlp :
memcpy(ncchset->CxiRsaKey.PrivK,(u8*)Dlp_sdk5_HdrPrivK,0x100);
memcpy(ncchset->CxiRsaKey.PubK,(u8*)Dlp_sdk5_HdrPubK,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.signature,(u8*)Dlp_sdk5_AcexData,0x400);
return 0;
#endif
if(ncchset->keys->AccessDescSign.PresetType == not_preset){
if(ncchset->yaml_set->CommonHeaderKey.Found)
return accessdesc_GetSignFromRsf(exhdrset,ncchset);
else if(!ncchset->keys->rsa.RequiresPresignedDesc)
return accessdesc_SignWithKey(exhdrset,ncchset);
else{
fprintf(stderr,"[EXHEADER ERROR] Current keyset cannot sign AccessDesc, please appropriatly setup RSF, or specify a preset with -accessdesc\n");
return CANNOT_SIGN_ACCESSDESC;
}
}
return accessdesc_GetSignFromPreset(exhdrset,ncchset);
}
int accessdesc_SignWithKey(exheader_settings *exhdrset, ncch_settings *ncchset)
{
/* Set RSA Keys */
memcpy(ncchset->CxiRsaKey.PrivK,exhdrset->keys->rsa.CFA_Priv,0x100);
memcpy(ncchset->CxiRsaKey.PubK,exhdrset->keys->rsa.CFA_Pub,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,exhdrset->keys->rsa.CFA_Pub,0x100);
/* Copy Data From ExHeader */
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,&exhdrset->ExHdr->ARM11SystemLocalCapabilities,sizeof(exhdr_ARM11SystemLocalCapabilities));
u8 *byte6 = &exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities.Flags[6];
u8 SystemMode = (*byte6>>4)&0xF;
u8 AffinityMask = (*byte6>>2)&0x3;
u8 IdealProcessor = ((*byte6>>0)&0x3)+1;
*byte6 = (u8)(SystemMode << 4 | AffinityMask << 2 | IdealProcessor);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11KernelCapabilities,&exhdrset->ExHdr->ARM11KernelCapabilities,sizeof(exhdr_ARM11KernelCapabilities));
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM9AccessControlInfo,&exhdrset->ExHdr->ARM9AccessControlInfo,sizeof(exhdr_ARM9AccessControlInfo));
/* Sign AccessDesc */
return SignAccessDesc(exhdrset->ExHdr,exhdrset->keys);
}
int accessdesc_GetSignFromRsf(exheader_settings *exhdrset, ncch_settings *ncchset)
{
/* Yaml Option Sanity Checks */
if(!exhdrset->yaml->CommonHeaderKey.Found){
fprintf(stderr,"[EXHEADER ERROR] RSF Section 'CommonHeaderKey' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.D){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/D' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.D) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/D' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.D));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.Modulus){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Modulus' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.Modulus) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Modulus' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.Modulus));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.AccCtlDescSign){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Signature' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign) != 350){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Signature' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign));
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(!exhdrset->yaml->CommonHeaderKey.AccCtlDescBin){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Descriptor' not found\n");
return COMMON_HEADER_KEY_NOT_FOUND;
}
if(strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin) != 695){
fprintf(stderr,"[EXHEADER ERROR] 'CommonHeaderKey/Descriptor' has invalid length (%d)\n",strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin));
return COMMON_HEADER_KEY_NOT_FOUND;
}
/* Set RSA Keys */
int result = 0;
u32 out = 0x500;
u8 *tmp = malloc(0x500);
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.Modulus,strlen(exhdrset->yaml->CommonHeaderKey.Modulus));
if(result) goto finish;
memcpy(ncchset->CxiRsaKey.PubK,tmp,0x100);
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.D,strlen(exhdrset->yaml->CommonHeaderKey.D));
if(result) goto finish;
memcpy(ncchset->CxiRsaKey.PrivK,tmp,0x100);
/* Set AccessDesc */
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.AccCtlDescSign,strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescSign));
if(result) goto finish;
memcpy(exhdrset->ExHdr->AccessDescriptor.signature,tmp,0x100);
memcpy(exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,ncchset->CxiRsaKey.PubK,0x100);
out = 0x500;
result = base64_decode(tmp,&out,(const u8*)exhdrset->yaml->CommonHeaderKey.AccCtlDescBin,strlen(exhdrset->yaml->CommonHeaderKey.AccCtlDescBin));
if(result) goto finish;
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,tmp,0x200);
finish:
free(tmp);
return result;
}
int accessdesc_GetSignFromPreset(exheader_settings *exhdrset, ncch_settings *ncchset)
{
u8 *AccessDescSig = NULL;
u8 *AccessDescData = NULL;
u8 *DepList = NULL;
u8 *CXI_Pubk = NULL;
u8 *CXI_Privk = NULL;
if(ncchset->keys->AccessDescSign.PresetType == app){
switch(ncchset->keys->AccessDescSign.TargetFirmware){
case 1:
AccessDescSig = (u8*)App_sdk1_AcexSig;
AccessDescData = (u8*)App_sdk1_AcexData;
DepList = (u8*)sdk1_dep_list;
CXI_Pubk = (u8*)App_sdk1_HdrPubK;
CXI_Privk = (u8*)App_sdk1_HdrPrivK;
break;
case 2:
AccessDescSig = (u8*)App_sdk2_AcexSig;
AccessDescData = (u8*)App_sdk2_AcexData;
DepList = (u8*)sdk2_dep_list;
CXI_Pubk = (u8*)App_sdk2_HdrPubK;
CXI_Privk = (u8*)App_sdk2_HdrPrivK;
break;
case 4:
case 5:
AccessDescSig = (u8*)App_sdk4_AcexSig;
AccessDescData = (u8*)App_sdk4_AcexData;
DepList = (u8*)sdk4_dep_list;
CXI_Pubk = (u8*)App_sdk4_HdrPubK;
CXI_Privk = (u8*)App_sdk4_HdrPrivK;
break;
case 7:
AccessDescSig = NULL;
AccessDescData = (u8*)App_sdk7_AcexData;
DepList = (u8*)sdk7_dep_list;
CXI_Pubk = NULL;
CXI_Privk = NULL;
break;
}
}
else if(ncchset->keys->AccessDescSign.PresetType == dlp){
switch(ncchset->keys->AccessDescSign.TargetFirmware){
case 1:
AccessDescSig = (u8*)Dlp_sdk1_AcexSig;
AccessDescData = (u8*)Dlp_sdk1_AcexData;
DepList = (u8*)sdk1_dep_list;
CXI_Pubk = (u8*)Dlp_sdk1_HdrPubK;
CXI_Privk = (u8*)Dlp_sdk1_HdrPrivK;
break;
case 2:
AccessDescSig = (u8*)Dlp_sdk2_AcexSig;
AccessDescData = (u8*)Dlp_sdk2_AcexData;
DepList = (u8*)sdk2_dep_list;
CXI_Pubk = (u8*)Dlp_sdk2_HdrPubK;
CXI_Privk = (u8*)Dlp_sdk2_HdrPrivK;
break;
case 4:
case 5:
AccessDescSig = (u8*)Dlp_sdk4_AcexSig;
AccessDescData = (u8*)Dlp_sdk4_AcexData;
DepList = (u8*)sdk4_dep_list;
CXI_Pubk = (u8*)Dlp_sdk4_HdrPubK;
CXI_Privk = (u8*)Dlp_sdk4_HdrPrivK;
break;
}
}
else if(ncchset->keys->AccessDescSign.PresetType == demo){
switch(ncchset->keys->AccessDescSign.TargetFirmware){
case 4:
case 5:
AccessDescSig = (u8*)Demo_sdk4_AcexSig;
AccessDescData = (u8*)Demo_sdk4_AcexData;
DepList = (u8*)sdk4_dep_list;
CXI_Pubk = (u8*)Demo_sdk4_HdrPubK;
CXI_Privk = (u8*)Demo_sdk4_HdrPrivK;
break;
}
}
// Error Checking
if(!AccessDescData || !DepList){
fprintf(stderr,"[EXHEADER ERROR] AccessDesc preset is unavailable, please configure RSF file\n");
return CANNOT_SIGN_ACCESSDESC;
}
if((!CXI_Pubk || !CXI_Privk || !AccessDescSig) && ncchset->keys->rsa.RequiresPresignedDesc){
fprintf(stderr,"[EXHEADER ERROR] This AccessDesc preset needs to be signed, the current keyset is incapable of doing so. Please configure RSF file with the appropriate signature data.\n");
return CANNOT_SIGN_ACCESSDESC;
}
// Setting data in Exheader
// Dependency List
memcpy(exhdrset->ExHdr->DependencyList,DepList,0x180);
// ARM11 Local Capabilities
exhdr_ARM11SystemLocalCapabilities *arm11local = (exhdr_ARM11SystemLocalCapabilities*)(AccessDescData);
// Backing Up Non Preset Details
u8 ProgramID[8];
memcpy(ProgramID,exhdrset->ExHdr->ARM11SystemLocalCapabilities.ProgramId,8);
exhdr_StorageInfo StorageInfoBackup;
memcpy(&StorageInfoBackup,&exhdrset->ExHdr->ARM11SystemLocalCapabilities.StorageInfo,sizeof(exhdr_StorageInfo));
// Setting Preset Data
memcpy(&exhdrset->ExHdr->ARM11SystemLocalCapabilities,arm11local,sizeof(exhdr_ARM11SystemLocalCapabilities));
// Restoring Non Preset Data
memcpy(exhdrset->ExHdr->ARM11SystemLocalCapabilities.ProgramId,ProgramID,8);
memcpy(&exhdrset->ExHdr->ARM11SystemLocalCapabilities.StorageInfo,&StorageInfoBackup,sizeof(exhdr_StorageInfo));
// Adjusting flags to prevent errors
u8 *byte6 = &exhdrset->ExHdr->ARM11SystemLocalCapabilities.Flags[6];
u8 SystemMode = (*byte6>>4)&0xF;
u8 AffinityMask = (*byte6>>2)&0x3;
u8 IdealProcessor = ((*byte6>>0)&0x3)-1;
*byte6 = (u8)(SystemMode << 4 | AffinityMask << 2 | IdealProcessor);
exhdrset->ExHdr->ARM11SystemLocalCapabilities.Flags[7] = 0x30;
// ARM11 Kernel Capabilities
exhdr_ARM11KernelCapabilities *arm11kernel = (exhdr_ARM11KernelCapabilities*)(AccessDescData+sizeof(exhdr_ARM11SystemLocalCapabilities));
memcpy(&exhdrset->ExHdr->ARM11KernelCapabilities,arm11kernel,(sizeof(exhdr_ARM11KernelCapabilities)));
// ARM9 Access Control
exhdr_ARM9AccessControlInfo *arm9 = (exhdr_ARM9AccessControlInfo*)(AccessDescData+sizeof(exhdr_ARM11SystemLocalCapabilities)+sizeof(exhdr_ARM11KernelCapabilities));
memcpy(&exhdrset->ExHdr->ARM9AccessControlInfo,arm9,(sizeof(exhdr_ARM9AccessControlInfo)));
// Setting AccessDesc Area
// Signing normally if possible
if(!ncchset->keys->rsa.RequiresPresignedDesc)
return accessdesc_SignWithKey(exhdrset,ncchset);
// Otherwise set static data & ncch hdr sig info
memcpy(ncchset->CxiRsaKey.PubK,CXI_Pubk,0x100);
memcpy(ncchset->CxiRsaKey.PrivK,CXI_Privk,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.signature,AccessDescSig,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,CXI_Pubk,0x100);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,AccessDescData,0x200);
return 0;
}
exheader.h
+44 -44
View File
@@ -5,6 +5,7 @@ typedef enum
{
COMMON_HEADER_KEY_NOT_FOUND = -10,
EXHDR_BAD_YAML_OPT = -11,
CANNOT_SIGN_ACCESSDESC = -12
} exheader_errors;
typedef enum
@@ -37,60 +38,60 @@ typedef enum
typedef enum
{
PERMIT_DEBUG,
FORCE_DEBUG,
CAN_USE_NON_ALPHABET_AND_NUMBER,
CAN_WRITE_SHARED_PAGE,
CAN_USE_PRIVILEGE_PRIORITY,
PERMIT_MAIN_FUNCTION_ARGUMENT,
CAN_SHARE_DEVICE_MEMORY,
RUNNABLE_ON_SLEEP,
SPECIAL_MEMORY_ARRANGE = 12,
othcap_PERMIT_DEBUG,
othcap_FORCE_DEBUG,
othcap_CAN_USE_NON_ALPHABET_AND_NUMBER,
othcap_CAN_WRITE_SHARED_PAGE,
othcap_CAN_USE_PRIVILEGE_PRIORITY,
othcap_PERMIT_MAIN_FUNCTION_ARGUMENT,
othcap_CAN_SHARE_DEVICE_MEMORY,
othcap_RUNNABLE_ON_SLEEP,
othcap_SPECIAL_MEMORY_ARRANGE = 12,
} OtherCapabilities_Flagbitmask;
typedef enum
{
CATEGORY_SYSTEM_APPLICATION,
CATEGORY_HARDWARE_CHECK,
CATEGORY_FILE_SYSTEM_TOOL,
DEBUG,
TWL_CARD_BACKUP,
TWL_NAND_DATA,
BOSS,
DIRECT_SDMC,
CORE,
CTR_NAND_RO,
CTR_NAND_RW,
CTR_NAND_RO_WRITE,
CATEGORY_SYSTEM_SETTINGS,
CARD_BOARD,
EXPORT_IMPORT_IVS,
DIRECT_SDMC_WRITE,
SWITCH_CLEANUP,
SAVE_DATA_MOVE,
SHOP,
SHELL,
CATEGORY_HOME_MENU
fsaccess_CATEGORY_SYSTEM_APPLICATION,
fsaccess_CATEGORY_HARDWARE_CHECK,
fsaccess_CATEGORY_FILE_SYSTEM_TOOL,
fsaccess_DEBUG,
fsaccess_TWL_CARD_BACKUP,
fsaccess_TWL_NAND_DATA,
fsaccess_BOSS,
fsaccess_DIRECT_SDMC,
fsaccess_CORE,
fsaccess_CTR_NAND_RO,
fsaccess_CTR_NAND_RW,
fsaccess_CTR_NAND_RO_WRITE,
fsaccess_CATEGORY_SYSTEM_SETTINGS,
fsaccess_CARD_BOARD,
fsaccess_EXPORT_IMPORT_IVS,
fsaccess_DIRECT_SDMC_WRITE,
fsaccess_SWITCH_CLEANUP,
fsaccess_SAVE_DATA_MOVE,
fsaccess_SHOP,
fsaccess_SHELL,
fsaccess_CATEGORY_HOME_MENU
} FileSystemAccess;
typedef enum
{
NOT_USE_ROMFS,
USE_EXTENDED_SAVEDATA_ACCESS_CONTROL
attribute_NOT_USE_ROMFS,
attribute_USE_EXTENDED_SAVEDATA_ACCESS_CONTROL
} AttributeName;
typedef enum
{
FS_MOUNT_NAND,
FS_MOUNT_NAND_RO_WRITE,
FS_MOUNT_TWLN,
FS_MOUNT_WNAND,
FS_MOUNT_CARD_SPI,
USE_SDIF3,
CREATE_SEED,
USE_CARD_SPI,
SD_APPLICATION,
USE_DIRECT_SDMC
arm9cap_FS_MOUNT_NAND,
arm9cap_FS_MOUNT_NAND_RO_WRITE,
arm9cap_FS_MOUNT_TWLN,
arm9cap_FS_MOUNT_WNAND,
arm9cap_FS_MOUNT_CARD_SPI,
arm9cap_USE_SDIF3,
arm9cap_CREATE_SEED,
arm9cap_USE_CARD_SPI,
arm9cap_SD_APPLICATION,
arm9cap_USE_DIRECT_SDMC
} Arm9Capability;
typedef struct
@@ -131,8 +132,6 @@ typedef struct
u8 ExtSaveDataId[8];
u8 SystemSaveDataId[8];
u8 StorageAccessableUniqueIds[8];
//u8 reserved[7];
//u8 flag;
u8 AccessInfo[7];
u8 OtherAttributes;
} exhdr_StorageInfo;
@@ -203,6 +202,7 @@ typedef struct
{
keys_struct *keys;
rsf_settings *yaml;
bool UseAccessDescPreset;
/* Output */
ExtendedHeader_Struct *ExHdr; // is the exheader output buffer ptr(in ncchset) cast as exheader struct ptr;
keys_common.h
+83
View File
@@ -0,0 +1,83 @@
#ifndef _KEYS_COMMON_H_
#define _KEYS_COMMON_H_
// AES KEYS
static const unsigned char zeros_fixed_aesKey[16] = //zeros_fixed_aesKey
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// RSA KEYS
static const unsigned char Dummy_rsa_privExp[256] = //Dummy_rsa_privExp
{
0xE3, 0xC6, 0x76, 0x57, 0x2E, 0xCB, 0xA5, 0xE6,
0x0C, 0x01, 0xBD, 0x5C, 0x32, 0x2D, 0x90, 0xE0,
0xFF, 0x9A, 0x80, 0xE8, 0x66, 0x8D, 0x84, 0xDC,
0xF7, 0x75, 0x5F, 0x3F, 0x98, 0x7C, 0x97, 0x40,
0x20, 0x21, 0xB7, 0x24, 0xC0, 0x61, 0x2D, 0x83,
0xB0, 0x91, 0x8E, 0xE3, 0xC2, 0xD0, 0x2C, 0xA1,
0x2C, 0x99, 0x4F, 0x48, 0xF7, 0x4E, 0x13, 0xD3,
0x01, 0x71, 0x25, 0x9B, 0x3C, 0x75, 0x7C, 0xC4,
0xE5, 0x89, 0x7E, 0xDA, 0xF9, 0x99, 0x5C, 0x83,
0xE4, 0xDD, 0x36, 0x62, 0x5B, 0x0E, 0x12, 0x91,
0xD6, 0x39, 0x45, 0x69, 0x62, 0x20, 0xCA, 0xF4,
0xBA, 0x6B, 0x28, 0x1A, 0x7C, 0xBF, 0xB9, 0x97,
0x37, 0x46, 0xC2, 0x7A, 0xCF, 0x10, 0x68, 0xC2,
0xC9, 0xF1, 0x48, 0xDA, 0x8A, 0x2F, 0x4C, 0xBC,
0x3B, 0x1C, 0xB8, 0x8F, 0x04, 0x7F, 0xFD, 0x9D,
0xE2, 0x0A, 0xD2, 0x09, 0x39, 0xC7, 0xD9, 0x81,
0x59, 0x17, 0x73, 0xB2, 0xEC, 0xEB, 0x36, 0x67,
0xA5, 0xA8, 0xD5, 0x71, 0xD9, 0x38, 0x6A, 0xD1,
0x28, 0xB9, 0x46, 0x85, 0x3A, 0x81, 0x85, 0x4E,
0x55, 0xA7, 0x74, 0x79, 0xBB, 0xC5, 0x97, 0xF7,
0xEF, 0xE0, 0x81, 0x20, 0xE0, 0xEA, 0x45, 0x8F,
0xED, 0x70, 0x8E, 0xD6, 0xFF, 0x49, 0xCF, 0x7F,
0xF2, 0xFF, 0x22, 0x20, 0x3F, 0xE9, 0x92, 0x99,
0xDE, 0x81, 0xD6, 0x27, 0xF7, 0xB8, 0x3A, 0x1D,
0x4F, 0xA2, 0x50, 0xFB, 0xA5, 0xE7, 0x98, 0x08,
0xB5, 0x2B, 0xA2, 0x94, 0xA9, 0x17, 0x1A, 0xA8,
0x34, 0xF6, 0x5E, 0x24, 0x2D, 0x40, 0x2F, 0xCB,
0x3C, 0xB0, 0xF8, 0x7E, 0x84, 0xB4, 0x87, 0x82,
0x19, 0xAF, 0x87, 0xB6, 0xFA, 0xA9, 0x67, 0x27,
0x07, 0x28, 0xBA, 0x2E, 0xA5, 0x8E, 0xDD, 0xE5,
0xD4, 0xFD, 0x06, 0x09, 0xDF, 0xBD, 0x87, 0x95,
0x95, 0x25, 0x05, 0x5E, 0xB2, 0x00, 0x18, 0x41
};
static const unsigned char Dummy_rsa_pubMod[256] = //Dummy_rsa_pubMod
{
0xE6, 0x64, 0x06, 0x6C, 0x49, 0x6B, 0xEC, 0xEE,
0x59, 0xAE, 0x11, 0x92, 0xF1, 0x03, 0x43, 0x87,
0x8E, 0xEB, 0x4D, 0x70, 0xA9, 0x71, 0xB4, 0x6D,
0x25, 0x19, 0x02, 0x4A, 0x9E, 0x4D, 0xA3, 0x10,
0xFD, 0xB2, 0x27, 0x56, 0xA3, 0xFB, 0xDD, 0xE5,
0xE4, 0x4E, 0xE0, 0x62, 0x8F, 0xC3, 0x2E, 0xEE,
0x8F, 0x9D, 0x4D, 0x6E, 0x00, 0xDB, 0x88, 0x49,
0xA2, 0xFC, 0x30, 0xFE, 0x94, 0xF3, 0x06, 0x92,
0x75, 0x61, 0x11, 0x1D, 0x24, 0x07, 0xE9, 0x12,
0xB6, 0xB1, 0x57, 0xF5, 0xDC, 0x01, 0xF7, 0x54,
0xBF, 0xC3, 0xAC, 0x8C, 0x73, 0x2C, 0x73, 0x17,
0x8E, 0xBF, 0x2F, 0x68, 0x3C, 0x61, 0x75, 0x32,
0x15, 0x39, 0x93, 0xDD, 0xBA, 0x12, 0x42, 0xD3,
0x25, 0x85, 0xFA, 0xA6, 0x4B, 0xAF, 0x81, 0x4B,
0xCA, 0xD2, 0x9C, 0xF1, 0x3D, 0x37, 0xAE, 0xB9,
0xFD, 0x77, 0x59, 0x78, 0xB9, 0x32, 0x95, 0x19,
0xD1, 0x47, 0xE1, 0xC6, 0xE1, 0x16, 0x13, 0x5D,
0xCC, 0x99, 0x31, 0x63, 0xAD, 0xBB, 0xA5, 0x4F,
0xE4, 0x41, 0x67, 0xFD, 0x7F, 0x1E, 0xA8, 0x9A,
0x35, 0x65, 0xEB, 0xC4, 0x4D, 0xD4, 0xC4, 0x29,
0x0F, 0x40, 0x95, 0xFD, 0x8A, 0x30, 0x67, 0x79,
0xFB, 0xD4, 0x76, 0x6F, 0xD1, 0xDE, 0x8C, 0x72,
0x32, 0x05, 0x97, 0x5A, 0x26, 0x0D, 0x37, 0xCA,
0x12, 0x2C, 0xDC, 0x14, 0x3F, 0xD3, 0x59, 0x00,
0x66, 0xD2, 0x8E, 0xF5, 0x6E, 0x22, 0x08, 0x63,
0x59, 0xB5, 0x3F, 0xBB, 0x3A, 0x4D, 0xD4, 0xD1,
0xC1, 0x21, 0xA7, 0x4D, 0x02, 0x96, 0x08, 0xF5,
0x2B, 0x11, 0xE5, 0x85, 0xD2, 0x6E, 0x91, 0xD6,
0x8F, 0x77, 0x72, 0xEF, 0x37, 0xE3, 0x79, 0x19,
0xA9, 0xEE, 0x58, 0x5D, 0x52, 0x9B, 0x2D, 0x47,
0x7D, 0x27, 0xB8, 0xC3, 0x76, 0xCA, 0xDA, 0xC2,
0xF4, 0xFC, 0xF4, 0x53, 0x7C, 0xD8, 0x43, 0x87
};
#endif
keys_debug.h
+2 -81
View File
@@ -1,13 +1,6 @@
#ifndef _KEYS_DEBUG_H_
#define _KEYS_DEBUG_H_
// AES KEYS
static const unsigned char zeros_fixed_aesKey[16] = //zeros_fixed_aesKey
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const unsigned char system_fixed_aesKey[16] = //system_fixed_aesKey
{
0x52, 0x7C, 0xE6, 0x30, 0xA9, 0xCA, 0x30, 0x5F,
@@ -26,7 +19,7 @@ static const unsigned char ctr_aes_common_key_dev1[16] = //ctr_aes_common_key_de
0xAB, 0x82, 0xC1, 0x6E, 0x7B, 0xEF, 0x0C, 0x25
};
static const unsigned char common_dpki_aesKey[16] = //common_dpki_aesKey
static const unsigned char common_dpki_aesKey[16] = //common_dpki_aesKey a.k.a. DSi DevCommonKey
{
0xA1, 0x60, 0x4A, 0x6A, 0x71, 0x23, 0xB5, 0x29,
0xAE, 0x8B, 0xEC, 0x32, 0xC8, 0x16, 0xFC, 0xAA
@@ -48,7 +41,7 @@ static const unsigned char xs_dpki_eccPubKey[60] = //xs_dpki_eccPubKey
//RSA Keys
static const unsigned char cert_root_rsa_pubk[0x200] =
static const unsigned char dev_cert_root_rsa_pubk[0x200] =
{
0xD0, 0x1F, 0xE1, 0x00, 0xD4, 0x35, 0x56, 0xB2,
0x4B, 0x56, 0xDA, 0xE9, 0x71, 0xB5, 0xA5, 0xD3,
@@ -476,78 +469,6 @@ static const unsigned char CrrDevKey_pubMod[256] = //CrrDevKey_pubMod
0xDA, 0x65, 0xE7, 0x6E, 0xEF, 0x2E, 0xF5, 0x67
};
static const unsigned char Dummy_rsa_privExp[256] = //Dummy_rsa_privExp
{
0xE3, 0xC6, 0x76, 0x57, 0x2E, 0xCB, 0xA5, 0xE6,
0x0C, 0x01, 0xBD, 0x5C, 0x32, 0x2D, 0x90, 0xE0,
0xFF, 0x9A, 0x80, 0xE8, 0x66, 0x8D, 0x84, 0xDC,
0xF7, 0x75, 0x5F, 0x3F, 0x98, 0x7C, 0x97, 0x40,
0x20, 0x21, 0xB7, 0x24, 0xC0, 0x61, 0x2D, 0x83,
0xB0, 0x91, 0x8E, 0xE3, 0xC2, 0xD0, 0x2C, 0xA1,
0x2C, 0x99, 0x4F, 0x48, 0xF7, 0x4E, 0x13, 0xD3,
0x01, 0x71, 0x25, 0x9B, 0x3C, 0x75, 0x7C, 0xC4,
0xE5, 0x89, 0x7E, 0xDA, 0xF9, 0x99, 0x5C, 0x83,
0xE4, 0xDD, 0x36, 0x62, 0x5B, 0x0E, 0x12, 0x91,
0xD6, 0x39, 0x45, 0x69, 0x62, 0x20, 0xCA, 0xF4,
0xBA, 0x6B, 0x28, 0x1A, 0x7C, 0xBF, 0xB9, 0x97,
0x37, 0x46, 0xC2, 0x7A, 0xCF, 0x10, 0x68, 0xC2,
0xC9, 0xF1, 0x48, 0xDA, 0x8A, 0x2F, 0x4C, 0xBC,
0x3B, 0x1C, 0xB8, 0x8F, 0x04, 0x7F, 0xFD, 0x9D,
0xE2, 0x0A, 0xD2, 0x09, 0x39, 0xC7, 0xD9, 0x81,
0x59, 0x17, 0x73, 0xB2, 0xEC, 0xEB, 0x36, 0x67,
0xA5, 0xA8, 0xD5, 0x71, 0xD9, 0x38, 0x6A, 0xD1,
0x28, 0xB9, 0x46, 0x85, 0x3A, 0x81, 0x85, 0x4E,
0x55, 0xA7, 0x74, 0x79, 0xBB, 0xC5, 0x97, 0xF7,
0xEF, 0xE0, 0x81, 0x20, 0xE0, 0xEA, 0x45, 0x8F,
0xED, 0x70, 0x8E, 0xD6, 0xFF, 0x49, 0xCF, 0x7F,
0xF2, 0xFF, 0x22, 0x20, 0x3F, 0xE9, 0x92, 0x99,
0xDE, 0x81, 0xD6, 0x27, 0xF7, 0xB8, 0x3A, 0x1D,
0x4F, 0xA2, 0x50, 0xFB, 0xA5, 0xE7, 0x98, 0x08,
0xB5, 0x2B, 0xA2, 0x94, 0xA9, 0x17, 0x1A, 0xA8,
0x34, 0xF6, 0x5E, 0x24, 0x2D, 0x40, 0x2F, 0xCB,
0x3C, 0xB0, 0xF8, 0x7E, 0x84, 0xB4, 0x87, 0x82,
0x19, 0xAF, 0x87, 0xB6, 0xFA, 0xA9, 0x67, 0x27,
0x07, 0x28, 0xBA, 0x2E, 0xA5, 0x8E, 0xDD, 0xE5,
0xD4, 0xFD, 0x06, 0x09, 0xDF, 0xBD, 0x87, 0x95,
0x95, 0x25, 0x05, 0x5E, 0xB2, 0x00, 0x18, 0x41
};
static const unsigned char Dummy_rsa_pubMod[256] = //Dummy_rsa_pubMod
{
0xE6, 0x64, 0x06, 0x6C, 0x49, 0x6B, 0xEC, 0xEE,
0x59, 0xAE, 0x11, 0x92, 0xF1, 0x03, 0x43, 0x87,
0x8E, 0xEB, 0x4D, 0x70, 0xA9, 0x71, 0xB4, 0x6D,
0x25, 0x19, 0x02, 0x4A, 0x9E, 0x4D, 0xA3, 0x10,
0xFD, 0xB2, 0x27, 0x56, 0xA3, 0xFB, 0xDD, 0xE5,
0xE4, 0x4E, 0xE0, 0x62, 0x8F, 0xC3, 0x2E, 0xEE,
0x8F, 0x9D, 0x4D, 0x6E, 0x00, 0xDB, 0x88, 0x49,
0xA2, 0xFC, 0x30, 0xFE, 0x94, 0xF3, 0x06, 0x92,
0x75, 0x61, 0x11, 0x1D, 0x24, 0x07, 0xE9, 0x12,
0xB6, 0xB1, 0x57, 0xF5, 0xDC, 0x01, 0xF7, 0x54,
0xBF, 0xC3, 0xAC, 0x8C, 0x73, 0x2C, 0x73, 0x17,
0x8E, 0xBF, 0x2F, 0x68, 0x3C, 0x61, 0x75, 0x32,
0x15, 0x39, 0x93, 0xDD, 0xBA, 0x12, 0x42, 0xD3,
0x25, 0x85, 0xFA, 0xA6, 0x4B, 0xAF, 0x81, 0x4B,
0xCA, 0xD2, 0x9C, 0xF1, 0x3D, 0x37, 0xAE, 0xB9,
0xFD, 0x77, 0x59, 0x78, 0xB9, 0x32, 0x95, 0x19,
0xD1, 0x47, 0xE1, 0xC6, 0xE1, 0x16, 0x13, 0x5D,
0xCC, 0x99, 0x31, 0x63, 0xAD, 0xBB, 0xA5, 0x4F,
0xE4, 0x41, 0x67, 0xFD, 0x7F, 0x1E, 0xA8, 0x9A,
0x35, 0x65, 0xEB, 0xC4, 0x4D, 0xD4, 0xC4, 0x29,
0x0F, 0x40, 0x95, 0xFD, 0x8A, 0x30, 0x67, 0x79,
0xFB, 0xD4, 0x76, 0x6F, 0xD1, 0xDE, 0x8C, 0x72,
0x32, 0x05, 0x97, 0x5A, 0x26, 0x0D, 0x37, 0xCA,
0x12, 0x2C, 0xDC, 0x14, 0x3F, 0xD3, 0x59, 0x00,
0x66, 0xD2, 0x8E, 0xF5, 0x6E, 0x22, 0x08, 0x63,
0x59, 0xB5, 0x3F, 0xBB, 0x3A, 0x4D, 0xD4, 0xD1,
0xC1, 0x21, 0xA7, 0x4D, 0x02, 0x96, 0x08, 0xF5,
0x2B, 0x11, 0xE5, 0x85, 0xD2, 0x6E, 0x91, 0xD6,
0x8F, 0x77, 0x72, 0xEF, 0x37, 0xE3, 0x79, 0x19,
0xA9, 0xEE, 0x58, 0x5D, 0x52, 0x9B, 0x2D, 0x47,
0x7D, 0x27, 0xB8, 0xC3, 0x76, 0xCA, 0xDA, 0xC2,
0xF4, 0xFC, 0xF4, 0x53, 0x7C, 0xD8, 0x43, 0x87
};
//Certificates
static const unsigned char ca4_dpki_cert[0x400] =
{
keys_retail.h
+70 -74
View File
@@ -1,15 +1,46 @@
#ifndef _KEYS_RETAIL_H_
#define _KEYS_RETAIL_H_
#ifndef PUBLIC_BUILD
// AES KEYS
static const unsigned char zeros_fixed_aesKey[16] = //zeros_fixed_aesKey
static const unsigned char common_key_prod_keyY0[16] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
0xD0, 0x7B, 0x33, 0x7F, 0x9C, 0xA4, 0x38, 0x59,
0x32, 0xA2, 0xE2, 0x57, 0x23, 0x23, 0x2E, 0xB9
};
static const unsigned char common_key_prod_keyY1[16] =
{
0x0C, 0x76, 0x72, 0x30, 0xF0, 0x99, 0x8F, 0x1C,
0x46, 0x82, 0x82, 0x02, 0xFA, 0xAC, 0xBE, 0x4C
};
static const unsigned char common_key_prod_keyY2[16] =
{
0xC4, 0x75, 0xCB, 0x3A, 0xB8, 0xC7, 0x88, 0xBB,
0x57, 0x5E, 0x12, 0xA1, 0x09, 0x07, 0xB8, 0xA4
};
static const unsigned char common_key_prod_keyY3[16] =
{
0xE4, 0x86, 0xEE, 0xE3, 0xD0, 0xC0, 0x9C, 0x90,
0x2F, 0x66, 0x86, 0xD4, 0xC0, 0x6F, 0x64, 0x9F
};
static const unsigned char common_key_prod_keyY4[16] =
{
0xED, 0x31, 0xBA, 0x9C, 0x04, 0xB0, 0x67, 0x50,
0x6C, 0x44, 0x97, 0xA3, 0x5B, 0x78, 0x04, 0xFC
};
static const unsigned char common_key_prod_keyY5[16] =
{
0x5E, 0x66, 0x99, 0x8A, 0xB4, 0xE8, 0x93, 0x16,
0x06, 0x85, 0x0F, 0xD7, 0xA1, 0x6D, 0xD7, 0x55
};
// RSA KEYS
static const unsigned char cert_root_rsa_pubk[0x200] =
static const unsigned char retail_cert_root_rsa_pubk[0x200] =
{
0xF8, 0x24, 0x6C, 0x58, 0xBA, 0xE7, 0x50, 0x03,
0x01, 0xFB, 0xB7, 0xC2, 0xEB, 0xE0, 0x01, 0x05,
@@ -77,7 +108,7 @@ static const unsigned char cert_root_rsa_pubk[0x200] =
0xCF, 0xC4, 0x4E, 0x1F, 0x91, 0xCB, 0xD4, 0x95
};
static const unsigned char AccessDesc_pubMod[0x100] =
static const unsigned char RetailAccessDesc_pubMod[0x100] =
{
0xB1, 0xE3, 0xE3, 0x5F, 0x01, 0x39, 0x80, 0xD1,
0x56, 0x78, 0x9D, 0xB7, 0x06, 0xF7, 0x1D, 0xBF,
@@ -149,77 +180,42 @@ static const unsigned char RetailNcsdCfa_pubMod[0x100] =
0x29, 0xAB, 0x69, 0x69, 0xC8, 0x28, 0xEE, 0x5D
};
static const unsigned char Dummy_rsa_privExp[256] = //Dummy_rsa_privExp
static const unsigned char retail_firm_pubk[0x100] =
{
0xE3, 0xC6, 0x76, 0x57, 0x2E, 0xCB, 0xA5, 0xE6,
0x0C, 0x01, 0xBD, 0x5C, 0x32, 0x2D, 0x90, 0xE0,
0xFF, 0x9A, 0x80, 0xE8, 0x66, 0x8D, 0x84, 0xDC,
0xF7, 0x75, 0x5F, 0x3F, 0x98, 0x7C, 0x97, 0x40,
0x20, 0x21, 0xB7, 0x24, 0xC0, 0x61, 0x2D, 0x83,
0xB0, 0x91, 0x8E, 0xE3, 0xC2, 0xD0, 0x2C, 0xA1,
0x2C, 0x99, 0x4F, 0x48, 0xF7, 0x4E, 0x13, 0xD3,
0x01, 0x71, 0x25, 0x9B, 0x3C, 0x75, 0x7C, 0xC4,
0xE5, 0x89, 0x7E, 0xDA, 0xF9, 0x99, 0x5C, 0x83,
0xE4, 0xDD, 0x36, 0x62, 0x5B, 0x0E, 0x12, 0x91,
0xD6, 0x39, 0x45, 0x69, 0x62, 0x20, 0xCA, 0xF4,
0xBA, 0x6B, 0x28, 0x1A, 0x7C, 0xBF, 0xB9, 0x97,
0x37, 0x46, 0xC2, 0x7A, 0xCF, 0x10, 0x68, 0xC2,
0xC9, 0xF1, 0x48, 0xDA, 0x8A, 0x2F, 0x4C, 0xBC,
0x3B, 0x1C, 0xB8, 0x8F, 0x04, 0x7F, 0xFD, 0x9D,
0xE2, 0x0A, 0xD2, 0x09, 0x39, 0xC7, 0xD9, 0x81,
0x59, 0x17, 0x73, 0xB2, 0xEC, 0xEB, 0x36, 0x67,
0xA5, 0xA8, 0xD5, 0x71, 0xD9, 0x38, 0x6A, 0xD1,
0x28, 0xB9, 0x46, 0x85, 0x3A, 0x81, 0x85, 0x4E,
0x55, 0xA7, 0x74, 0x79, 0xBB, 0xC5, 0x97, 0xF7,
0xEF, 0xE0, 0x81, 0x20, 0xE0, 0xEA, 0x45, 0x8F,
0xED, 0x70, 0x8E, 0xD6, 0xFF, 0x49, 0xCF, 0x7F,
0xF2, 0xFF, 0x22, 0x20, 0x3F, 0xE9, 0x92, 0x99,
0xDE, 0x81, 0xD6, 0x27, 0xF7, 0xB8, 0x3A, 0x1D,
0x4F, 0xA2, 0x50, 0xFB, 0xA5, 0xE7, 0x98, 0x08,
0xB5, 0x2B, 0xA2, 0x94, 0xA9, 0x17, 0x1A, 0xA8,
0x34, 0xF6, 0x5E, 0x24, 0x2D, 0x40, 0x2F, 0xCB,
0x3C, 0xB0, 0xF8, 0x7E, 0x84, 0xB4, 0x87, 0x82,
0x19, 0xAF, 0x87, 0xB6, 0xFA, 0xA9, 0x67, 0x27,
0x07, 0x28, 0xBA, 0x2E, 0xA5, 0x8E, 0xDD, 0xE5,
0xD4, 0xFD, 0x06, 0x09, 0xDF, 0xBD, 0x87, 0x95,
0x95, 0x25, 0x05, 0x5E, 0xB2, 0x00, 0x18, 0x41
};
static const unsigned char Dummy_rsa_pubMod[256] = //Dummy_rsa_pubMod
{
0xE6, 0x64, 0x06, 0x6C, 0x49, 0x6B, 0xEC, 0xEE,
0x59, 0xAE, 0x11, 0x92, 0xF1, 0x03, 0x43, 0x87,
0x8E, 0xEB, 0x4D, 0x70, 0xA9, 0x71, 0xB4, 0x6D,
0x25, 0x19, 0x02, 0x4A, 0x9E, 0x4D, 0xA3, 0x10,
0xFD, 0xB2, 0x27, 0x56, 0xA3, 0xFB, 0xDD, 0xE5,
0xE4, 0x4E, 0xE0, 0x62, 0x8F, 0xC3, 0x2E, 0xEE,
0x8F, 0x9D, 0x4D, 0x6E, 0x00, 0xDB, 0x88, 0x49,
0xA2, 0xFC, 0x30, 0xFE, 0x94, 0xF3, 0x06, 0x92,
0x75, 0x61, 0x11, 0x1D, 0x24, 0x07, 0xE9, 0x12,
0xB6, 0xB1, 0x57, 0xF5, 0xDC, 0x01, 0xF7, 0x54,
0xBF, 0xC3, 0xAC, 0x8C, 0x73, 0x2C, 0x73, 0x17,
0x8E, 0xBF, 0x2F, 0x68, 0x3C, 0x61, 0x75, 0x32,
0x15, 0x39, 0x93, 0xDD, 0xBA, 0x12, 0x42, 0xD3,
0x25, 0x85, 0xFA, 0xA6, 0x4B, 0xAF, 0x81, 0x4B,
0xCA, 0xD2, 0x9C, 0xF1, 0x3D, 0x37, 0xAE, 0xB9,
0xFD, 0x77, 0x59, 0x78, 0xB9, 0x32, 0x95, 0x19,
0xD1, 0x47, 0xE1, 0xC6, 0xE1, 0x16, 0x13, 0x5D,
0xCC, 0x99, 0x31, 0x63, 0xAD, 0xBB, 0xA5, 0x4F,
0xE4, 0x41, 0x67, 0xFD, 0x7F, 0x1E, 0xA8, 0x9A,
0x35, 0x65, 0xEB, 0xC4, 0x4D, 0xD4, 0xC4, 0x29,
0x0F, 0x40, 0x95, 0xFD, 0x8A, 0x30, 0x67, 0x79,
0xFB, 0xD4, 0x76, 0x6F, 0xD1, 0xDE, 0x8C, 0x72,
0x32, 0x05, 0x97, 0x5A, 0x26, 0x0D, 0x37, 0xCA,
0x12, 0x2C, 0xDC, 0x14, 0x3F, 0xD3, 0x59, 0x00,
0x66, 0xD2, 0x8E, 0xF5, 0x6E, 0x22, 0x08, 0x63,
0x59, 0xB5, 0x3F, 0xBB, 0x3A, 0x4D, 0xD4, 0xD1,
0xC1, 0x21, 0xA7, 0x4D, 0x02, 0x96, 0x08, 0xF5,
0x2B, 0x11, 0xE5, 0x85, 0xD2, 0x6E, 0x91, 0xD6,
0x8F, 0x77, 0x72, 0xEF, 0x37, 0xE3, 0x79, 0x19,
0xA9, 0xEE, 0x58, 0x5D, 0x52, 0x9B, 0x2D, 0x47,
0x7D, 0x27, 0xB8, 0xC3, 0x76, 0xCA, 0xDA, 0xC2,
0xF4, 0xFC, 0xF4, 0x53, 0x7C, 0xD8, 0x43, 0x87
0xDE, 0xCF, 0xB6, 0xFC, 0x3D, 0x33, 0xE9, 0x55,
0xFD, 0xAC, 0x90, 0xE8, 0x88, 0x17, 0xB0, 0x03,
0xA1, 0x6B, 0x9A, 0xAB, 0x72, 0x70, 0x79, 0x32,
0xA2, 0xA0, 0x8C, 0xBB, 0x33, 0x6F, 0xB0, 0x76,
0x96, 0x2E, 0xC4, 0xE9, 0x2E, 0xD8, 0x8F, 0x92,
0xC0, 0x2D, 0x4D, 0x41, 0x0F, 0xDE, 0x45, 0x1B,
0x25, 0x3C, 0xBE, 0x37, 0x6B, 0x45, 0x82, 0x21,
0xE6, 0x4D, 0xB1, 0x23, 0x81, 0x82, 0xB6, 0x81,
0x62, 0xB7, 0x30, 0xF4, 0x60, 0x4B, 0xC7, 0xF7,
0xF0, 0x17, 0x0C, 0xB5, 0x75, 0x88, 0x77, 0x93,
0x52, 0x63, 0x70, 0xF0, 0x0B, 0xC6, 0x73, 0x43,
0x41, 0xEE, 0xE4, 0xF0, 0x71, 0xEC, 0xC8, 0xC1,
0x32, 0xC4, 0xDC, 0xA9, 0x99, 0x1D, 0x31, 0xB8,
0xA4, 0x7E, 0xDD, 0x19, 0x04, 0x0F, 0x02, 0xA8,
0x1A, 0xAF, 0xB3, 0x48, 0x9A, 0x29, 0x29, 0x5E,
0x49, 0x84, 0xE0, 0x94, 0x11, 0xD1, 0x7E, 0xAB,
0xB2, 0xC0, 0x44, 0x7E, 0xA1, 0x1B, 0x5E, 0x9D,
0x0D, 0x1A, 0xF9, 0x02, 0x9A, 0x2E, 0x53, 0x03,
0x2D, 0x48, 0x96, 0x7C, 0x2C, 0xA6, 0xD7, 0xAC,
0xF1, 0xED, 0x2B, 0x18, 0xBB, 0x01, 0xCB, 0x13,
0xB9, 0xAC, 0xA6, 0xEE, 0x55, 0x00, 0x37, 0x7C,
0x69, 0x61, 0x62, 0x89, 0x01, 0x54, 0x77, 0x9F,
0x07, 0x5D, 0x26, 0x34, 0x3A, 0xA9, 0x49, 0xA5,
0xAF, 0xF2, 0x5E, 0x06, 0x51, 0xB7, 0x1C, 0xE0,
0xDE, 0xDA, 0x5C, 0x0B, 0x9F, 0x98, 0xC2, 0x15,
0xFD, 0xBA, 0xD8, 0xA9, 0x99, 0x00, 0xAB, 0xA4,
0x8E, 0x4A, 0x16, 0x9D, 0x66, 0x2A, 0xE8, 0x56,
0x64, 0xB2, 0xB6, 0xC0, 0x93, 0xAF, 0x4D, 0x38,
0xA0, 0x16, 0x5C, 0xE4, 0xBD, 0x62, 0xC2, 0x46,
0x6B, 0xC9, 0x5A, 0x59, 0x4A, 0x72, 0x58, 0xFD,
0xB2, 0xCC, 0x36, 0x87, 0x30, 0x85, 0xE8, 0xA1,
0x04, 0x5B, 0xE0, 0x17, 0x9B, 0xD0, 0xEC, 0x9B
};
#endif
//Certificates
static const unsigned char ca3_dpki_cert[0x400] =
keyset.c
+80 -49
View File
@@ -1,8 +1,16 @@
#include "lib.h"
// KeyData
#include "keys_common.h"
#include "keys_retail.h"
#ifndef PUBLIC_BUILD
#include "keys_debug.h"
#endif
// Private Prototypes
int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource);
int SetUnFixedKey(keys_struct *keys, u8 *UnFixedKey);
void InitCommonKeySlots(keys_struct *keys);
int SetTIK_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetTMD_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
@@ -20,59 +28,78 @@ int SetTmdCert(keys_struct *keys, u8 *Cert);
void InitKeys(keys_struct *keys)
{
memset(keys,0,sizeof(keys_struct));
#ifdef RETAIL_FSIGN
/* AES Keys */
// CIA
SetCommonKey(keys,(u8*)zeros_fixed_aesKey,1);
SetCurrentCommonKey(keys,1);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
//SetSystemFixedKey(keys,(u8*)zeros_fixed_aesKey);
InitCommonKeySlots(keys);
}
/* RSA Keys */
// CIA
SetTIK_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
void SetKeys(keys_struct *keys)
{
if(keys->keyset == keyset_RETAIL){
/* AES Keys */
// CIA
//SetCommonKey(keys,(u8*)zeros_fixed_aesKey,1);
SetCurrentCommonKey(keys,1);
/* Certs */
SetCaCert(keys,(u8*)ca3_dpki_cert);
SetTikCert(keys,(u8*)xsC_dpki_cert);
SetTmdCert(keys,(u8*)cpB_dpki_cert);
#else // DEBUG KEYS
/* AES Keys */
// CIA
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev0,0);
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev1,1);
SetCurrentCommonKey(keys,0);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
/* RSA Keys */
// CIA
SetTIK_RsaKey(keys,(u8*)xs9_dpki_rsa_privExp,(u8*)xs9_dpki_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)cpA_dpki_rsa_privExp,(u8*)cpA_dpki_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)AccessDesc_privExp,(u8*)AccessDesc_pubMod);
/* RSA Keys */
keys->rsa.FalseSign = true;
// CIA
SetTIK_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
/* Certs */
SetCaCert(keys,(u8*)ca4_dpki_cert);
SetTikCert(keys,(u8*)xs9_dpki_cert);
SetTmdCert(keys,(u8*)cpA_dpki_cert);
/* Certs */
SetCaCert(keys,(u8*)ca3_dpki_cert);
SetTikCert(keys,(u8*)xsC_dpki_cert);
SetTmdCert(keys,(u8*)cpB_dpki_cert);
}
#ifndef PUBLIC_BUILD
else if(keys->keyset == keyset_DEBUG){
/* AES Keys */
// CIA
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev0,0);
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev1,1);
SetCurrentCommonKey(keys,0);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
/* RSA Keys */
// CIA
SetTIK_RsaKey(keys,(u8*)xs9_dpki_rsa_privExp,(u8*)xs9_dpki_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)cpA_dpki_rsa_privExp,(u8*)cpA_dpki_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)AccessDesc_privExp,(u8*)AccessDesc_pubMod);
/* Certs */
SetCaCert(keys,(u8*)ca4_dpki_cert);
SetTikCert(keys,(u8*)xs9_dpki_cert);
SetTmdCert(keys,(u8*)cpA_dpki_cert);
}
#endif
// Checking if AccessDesc can be signed
u8 *tmp = malloc(0x100);
memset(tmp,0,0x100);
if(memcmp(tmp,keys->rsa.AccessDesc_Priv,0x100) == 0)
keys->rsa.RequiresPresignedDesc = true;
else
keys->rsa.RequiresPresignedDesc = false;
free(tmp);
return;
}
void FreeKeys(keys_struct *keys)
@@ -126,11 +153,15 @@ int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource)
int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index)
{
if(!keys) return -1;
return CopyData(&keys->aes.CommonKey[Index],CommonKey,16);
}
void InitCommonKeySlots(keys_struct *keys)
{
if(!keys->aes.CommonKey){
keys->aes.CommonKey = malloc(sizeof(u8*)*256);
memset(keys->aes.CommonKey,0,sizeof(u8*)*256);
}
return CopyData(&keys->aes.CommonKey[Index],CommonKey,16);
}
int SetCurrentCommonKey(keys_struct *keys, u8 Index)
keyset.h
+25
View File
@@ -1,10 +1,32 @@
#ifndef _KEYSET_H_
#define _KEYSET_H_
typedef enum
{
keyset_DEBUG,
keyset_RETAIL,
} keysets;
typedef enum
{
not_preset,
app,
dlp,
demo,
} fixed_accessdesc_type;
// Structs
typedef struct
{
keysets keyset;
struct
{
fixed_accessdesc_type PresetType;
u32 TargetFirmware;
} AccessDescSign;
struct
{
// CIA
@@ -19,6 +41,7 @@ typedef struct
struct
{
bool FalseSign;
// CIA RSA
u8 *TMD_Priv;
u8 *TMD_Pub;
@@ -34,6 +57,7 @@ typedef struct
u8 *CCI_Pub;
// CXI
bool RequiresPresignedDesc;
u8 *AccessDesc_Priv;
u8 *AccessDesc_Pub;
} rsa;
@@ -51,6 +75,7 @@ typedef struct
// Public Prototypes
void InitKeys(keys_struct *keys);
void SetKeys(keys_struct *keys);
void FreeKeys(keys_struct *keys);
int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index);
lib.h
+1 -6
View File
@@ -26,12 +26,7 @@
#include "types.h"
#include "utils.h"
#include "crypto.h"
#ifdef RETAIL_FSIGN
#include "keys_retail.h"
#else
#include "keys_debug.h"
#include "accessdesc_sig.h"
#endif
#include "keyset.h"
#include "usersettings.h"
#include "libyaml/yaml.h"
makerom.c
+45 -12
View File
@@ -12,19 +12,30 @@ int main(int argc, char *argv[])
int result;
#ifdef DEBUG
printf("[DEBUG] Parseing Args\n");
#endif
// Parsing command args
result = ParseArgs(argc,argv,usrset);
if(result < 0) goto fail_finalise;
if(result < 0) goto finish;
#ifdef DEBUG
printf("[DEBUG] Importing Yaml Settings\n");
#endif
// Import RSF Settings if present
result = GetYamlSettings(usrset);
if(result < 0) goto fail_finalise;
if(result < 0) goto finish;
// Setup Content 0
if(!usrset->IsBuildingNCCH0){ // Import Content 0
if(usrset->Content0IsNcch){
#ifdef DEBUG
printf("[DEBUG] Import NCCH0\n");
#endif
FILE *ncch0 = fopen(usrset->ContentPath[0],"rb");
if(!ncch0) {fprintf(stderr,"[MAKEROM ERROR] Failed to open Content 0: %s\n",usrset->ContentPath[0]); goto fail_finalise;}
if(!ncch0) {fprintf(stderr,"[MAKEROM ERROR] Failed to open Content 0: %s\n",usrset->ContentPath[0]); goto finish;}
fclose(ncch0);
usrset->Content0.size = GetFileSize_u64(usrset->ContentPath[0]);
usrset->Content0.buffer = malloc(usrset->Content0.size);
@@ -33,8 +44,11 @@ int main(int argc, char *argv[])
fclose(ncch0);
}
else if(usrset->Content0IsSrl){
#ifdef DEBUG
printf("[DEBUG] Import SRL\n");
#endif
FILE *srl = fopen(usrset->SrlPath,"rb");
if(!srl) {fprintf(stderr,"[MAKEROM ERROR] Failed to open SRL: %s\n",usrset->SrlPath); goto fail_finalise;}
if(!srl) {fprintf(stderr,"[MAKEROM ERROR] Failed to open SRL: %s\n",usrset->SrlPath); goto finish;}
fclose(srl);
u64 size = GetFileSize_u64(usrset->SrlPath);
usrset->Content0.size = align_value(size,0x10);
@@ -44,8 +58,11 @@ int main(int argc, char *argv[])
fclose(srl);
}
else if(usrset->ConvertCci){
#ifdef DEBUG
printf("[DEBUG] Import CCI\n");
#endif
FILE *cci = fopen(usrset->CciPath,"rb");
if(!cci) {fprintf(stderr,"[MAKEROM ERROR] Failed to open CCI: %s\n",usrset->CciPath); goto fail_finalise;}
if(!cci) {fprintf(stderr,"[MAKEROM ERROR] Failed to open CCI: %s\n",usrset->CciPath); goto finish;}
fclose(cci);
usrset->Content0.size = GetFileSize_u64(usrset->CciPath);
usrset->Content0.buffer = malloc(usrset->Content0.size);
@@ -55,39 +72,55 @@ int main(int argc, char *argv[])
}
}
else{// Build Content 0
#ifdef DEBUG
printf("[DEBUG] Build NCCH0\n");
#endif
result = build_NCCH(usrset);
if(result < 0) {
//fprintf(stderr,"[ERROR] %s generation failed\n",usrset->build_ncch_type == CXI? "CXI" : "CFA");
fprintf(stderr,"[RESULT] Failed to build outfile\n");
goto fail_finalise;
goto finish;
}
}
// Make CCI
if(usrset->out_format == CCI){
#ifdef DEBUG
printf("[DEBUG] Building CCI\n");
#endif
result = build_CCI(usrset);
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CCI\n"); goto fail_finalise; }
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CCI\n"); goto finish; }
}
// Make CIA
else if(usrset->out_format == CIA){
#ifdef DEBUG
printf("[DEBUG] Building CIA\n");
#endif
result = build_CIA(usrset);
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CIA\n"); goto fail_finalise; }
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CIA\n"); goto finish; }
}
// No Container Raw CXI/CFA
else if(usrset->out_format == CXI || usrset->out_format == CFA){
#ifdef DEBUG
printf("[DEBUG] Outputting NCCH, because No Container\n");
#endif
FILE *ncch_out = fopen(usrset->outfile,"wb");
if(!ncch_out) {
fprintf(stderr,"[ERROR] Failed to create '%s'\n",usrset->outfile);
fprintf(stderr,"[RESULT] Failed to build '%s'\n",usrset->out_format == CXI? "CXI" : "CFA");
result = FAILED_TO_CREATE_OUTFILE;
goto fail_finalise;
goto finish;
}
WriteBuffer(usrset->Content0.buffer,usrset->Content0.size,0,ncch_out);
fclose(ncch_out);
}
finish:
#ifdef DEBUG
printf("[DEBUG] Free Context\n");
#endif
free_UserSettings(usrset);
return 0;
fail_finalise:
free_UserSettings(usrset);
#ifdef DEBUG
printf("[DEBUG] Finished returning (result=%d)\n",result);
#endif
return result;
}
ncch.c
+51 -27
View File
@@ -5,7 +5,8 @@
#include "exefs.h"
#include "romfs.h"
#include "titleid.h"
#include "logo_data.h"
#include "logo_data.h" // Contains Logos
// Private Prototypes
int SignCFA(u8 *Signature, u8 *CFA_HDR, keys_struct *keys);
@@ -57,16 +58,23 @@ int CheckCXISignature(u8 *Signature, u8 *CXI_HDR, u8 *PubK)
int build_NCCH(user_settings *usrset)
{
int result;
#ifdef DEBUG
printf("[DEBUG] Init Settings\n");
#endif
// Init Settings
ncch_settings *ncchset = malloc(sizeof(ncch_settings));
if(!ncchset) {fprintf(stderr,"[NCCH ERROR] MEM ERROR\n"); return MEM_ERROR;}
init_NCCHSettings(ncchset);
#ifdef DEBUG
printf("[DEBUG] Get Settings\n");
#endif
// Get Settings
result = get_NCCHSettings(ncchset,usrset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Build ExeFS Code/PlainRegion\n");
#endif
// Build ExeFs Code Section
result = BuildExeFsCode(ncchset);
if(result) goto finish;
@@ -82,25 +90,46 @@ int build_NCCH(user_settings *usrset)
memdump(stdout,"Code Hash: ",hash,0x20);
#endif
#ifdef DEBUG
printf("[DEBUG] Build Exheader\n");
#endif
// Build ExHeader
result = BuildExHeader(ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Exefs\n");
#endif
// Build ExeFs/RomFs
result = BuildExeFs(ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Build Romfs\n");
#endif
result = BuildRomFs(ncchset);
if(result) goto finish;
// Final Steps
#ifdef DEBUG
printf("[DEBUG] Build common header\n");
#endif
result = BuildCommonHeader(ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Encrypt Sections\n");
#endif
result = EncryptNCCHSections(ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Write Sections\n");
#endif
result = WriteNCCHSectionsToBuffer(ncchset);
if(result) goto finish;
finish:
#ifdef DEBUG
printf("[DEBUG] Finish Building\n");
#endif
if(result) fprintf(stderr,"[NCCH ERROR] NCCH Build Process Failed\n");
free_NCCHSettings(ncchset);
return result;
@@ -194,8 +223,6 @@ int SetBasicOptions(ncch_settings *ncchset, user_settings *usrset)
return NCCH_BAD_YAML_SET;
}
ncchset->Options.accessdesc = usrset->accessdesc;
ncchset->CxiRsaKey.PrivK = malloc(0x100);
ncchset->CxiRsaKey.PubK = malloc(0x100);
@@ -204,6 +231,15 @@ int SetBasicOptions(ncch_settings *ncchset, user_settings *usrset)
int CreateInputFilePtrs(ncch_settings *ncchset, user_settings *usrset)
{
if(usrset->romfs_path){
ncchset->ComponentFilePtrs.romfs_size = GetFileSize_u64(usrset->romfs_path);
ncchset->ComponentFilePtrs.romfs = fopen(usrset->romfs_path,"rb");
if(!ncchset->ComponentFilePtrs.romfs){
fprintf(stderr,"[NCCH ERROR] Failed to open RomFs file '%s'\n",usrset->romfs_path);
return FAILED_TO_IMPORT_FILE;
}
}
if(ncchset->Options.IsCfa) return 0;
if(usrset->elf_path){
ncchset->ComponentFilePtrs.elf_size = GetFileSize_u64(usrset->elf_path);
ncchset->ComponentFilePtrs.elf = fopen(usrset->elf_path,"rb");
@@ -253,14 +289,6 @@ int CreateInputFilePtrs(ncch_settings *ncchset, user_settings *usrset)
return FAILED_TO_IMPORT_FILE;
}
}
if(usrset->romfs_path){
ncchset->ComponentFilePtrs.romfs_size = GetFileSize_u64(usrset->romfs_path);
ncchset->ComponentFilePtrs.romfs = fopen(usrset->romfs_path,"rb");
if(!ncchset->ComponentFilePtrs.romfs){
fprintf(stderr,"[NCCH ERROR] Failed to open RomFs file '%s'\n",usrset->romfs_path);
return FAILED_TO_IMPORT_FILE;
}
}
if(usrset->plain_region_path){
ncchset->ComponentFilePtrs.plainregion_size = GetFileSize_u64(usrset->plain_region_path);
ncchset->ComponentFilePtrs.plainregion = fopen(usrset->plain_region_path,"rb");
@@ -274,6 +302,7 @@ int CreateInputFilePtrs(ncch_settings *ncchset, user_settings *usrset)
int ImportNonCodeExeFsSections(ncch_settings *ncchset)
{
if(ncchset->Options.IsCfa) return 0;
if(ncchset->ComponentFilePtrs.banner){
ncchset->ExeFs_Sections.Banner.size = ncchset->ComponentFilePtrs.banner_size;
ncchset->ExeFs_Sections.Banner.buffer = malloc(ncchset->ExeFs_Sections.Banner.size);
@@ -291,6 +320,7 @@ int ImportNonCodeExeFsSections(ncch_settings *ncchset)
int ImportLogo(ncch_settings *ncchset)
{
if(ncchset->Options.IsCfa) return 0;
if(ncchset->ComponentFilePtrs.logo){
ncchset->Sections.Logo.size = ncchset->ComponentFilePtrs.logo_size;
ncchset->Sections.Logo.buffer = malloc(ncchset->Sections.Logo.size);
@@ -599,14 +629,10 @@ int VerifyNCCH(u8 *ncch, keys_struct *keys, bool SuppressOutput)
GetCXIStruct(ncch_ctx,hdr);
if(IsCfa(hdr)){
if(CheckCFASignature(hdr_sig,(u8*)hdr,keys) != Good){
#ifdef RETAIL_FSIGN
if(!SuppressOutput) fprintf(stderr,"[NCCH WARNING] CFA Sigcheck Failed\n");
#else
if(CheckCFASignature(hdr_sig,(u8*)hdr,keys) != Good && !keys->rsa.FalseSign){
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CFA Sigcheck Failed\n");
free(ncch_ctx);
return NCCH_HDR_SIG_BAD;
#endif
}
if(!ncch_ctx->romfs_size){
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CFA is corrupt\n");
@@ -692,17 +718,13 @@ int VerifyNCCH(u8 *ncch, keys_struct *keys, bool SuppressOutput)
// Checking RSA Sigs
u8 *hdr_pubk = GetNcchHdrPubKey_frm_exhdr(ExHeader);
if(CheckAccessDescSignature(ExHeader,keys) != 0){
#ifdef RETAIL_FSIGN
if(!SuppressOutput) fprintf(stderr,"[NCCH WARNING] AccessDesc Sigcheck Failed\n");
#else
if(CheckAccessDescSignature(ExHeader,keys) != 0 && !keys->rsa.FalseSign){
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] AccessDesc Sigcheck Failed\n");
free(ncch_ctx);
free(ExHeader);
return ACCESSDESC_SIG_BAD;
#endif
}
if(CheckCXISignature(hdr_sig,(u8*)hdr,hdr_pubk) != 0){
if(CheckCXISignature(hdr_sig,(u8*)hdr,hdr_pubk) != 0 /* && !keys->rsa.FalseSign*/){
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CXI Header Sigcheck Failed\n");
free(ncch_ctx);
free(ExHeader);
@@ -780,8 +802,8 @@ u8* RetargetNCCH(FILE *fp, u64 size, u8 *TitleId, u8 *ProgramId, keys_struct *ke
NCCH_Header *hdr = NULL;
hdr = GetNCCH_CommonHDR(NULL,NULL,ncch);
if(!IsCfa(hdr)){
fprintf(stderr,"[NCCH ERROR] CXI's ID cannot be modified\n"); // Not yet yet, requires AccessDesc Privk, may implement anyway later
if(/*keys->rsa.RequiresPresignedDesc && */!IsCfa(hdr)){
fprintf(stderr,"[NCCH ERROR] CXI's ID cannot be modified without the ability to resign the AccessDesc\n"); // Not yet yet, requires AccessDesc Privk, may implement anyway later
free(ncch);
return NULL;
}
@@ -1060,4 +1082,6 @@ void ncch_get_counter(NCCH_STRUCT *ctx, u8 counter[16], u8 type)
for(i=0; i<4; i++)
counter[12+i] = x>>((3-i)*8);
}
//memdump(stdout,"CTR: ",counter,16);
}
ncch.h
-3
View File
@@ -135,9 +135,6 @@ typedef struct
struct
{
u32 MediaSize;
fixed_accessdesc_type accessdesc;
bool IncludeExeFsLogo;
bool CompressCode;
bool UseOnSD;
ncsd.c
+3
View File
@@ -413,6 +413,8 @@ int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml)
}
/* Platform */
cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
/*
if(!yaml->TitleInfo.Platform) cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
else{
if(strcasecmp(yaml->TitleInfo.Platform,"ctr") == 0) cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
@@ -421,6 +423,7 @@ int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml)
return INVALID_YAML_OPT;
}
}
*/
/* CardDevice */
if(!yaml->CardInfo.CardDevice) cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NONE;
tik.c
+6 -9
View File
@@ -6,7 +6,7 @@
int SetupTicketBuffer(COMPONENT_STRUCT *tik);
int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset);
int SignTicketHeader(TicketStruct *hdr, TicketSignatureStruct *sig, keys_struct *keys);
void SetUnknownTicketData(u8 *dest, u8 type);
void SetContentIndexData(u8 *dest);
int BuildTicket(cia_settings *ciaset)
@@ -42,13 +42,14 @@ int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset)
hdr->TicketFormatVersion = ciaset->tik.ticket_format_ver;
hdr->ca_crl_version = ciaset->cert.ca_crl_version;
hdr->signer_crl_version = ciaset->cert.signer_crl_version;
CryptTitleKey(hdr->EncryptedTitleKey, ciaset->tik.TitleKey,ciaset->TitleID,ciaset->keys,ENC);
if(ciaset->content.EncryptContents)
CryptTitleKey(hdr->EncryptedTitleKey, ciaset->tik.TitleKey,ciaset->TitleID,ciaset->keys,ENC);
memcpy(hdr->TicketID,ciaset->tik.TicketID,8);
memcpy(hdr->DeviceID,ciaset->tik.DeviceID,8);
memcpy(hdr->TitleID,ciaset->TitleID,8);
memcpy(hdr->TicketVersion,ciaset->tik.TicketVersion,2);
hdr->CommonKeyID = ciaset->keys->aes.CurrentCommonKey;
SetUnknownTicketData(hdr->StaticData,ciaset->tik.UnknownDataType);
SetContentIndexData(hdr->StaticData);
return 0;
}
@@ -79,11 +80,7 @@ int CryptTitleKey(u8 *EncTitleKey, u8 *DecTitleKey, u8 *TitleID, keys_struct *ke
return 0;
}
void SetUnknownTicketData(u8 *dest, u8 type)
void SetContentIndexData(u8 *dest)
{
switch(type){
case tik_normal: memcpy(dest,normal_static_ticket_data,0x30); break;
case tik_system: memcpy(dest,system_static_ticket_data,0x30); break;
case tik_test: memset(dest,0xff,0x30); break;
}
memcpy(dest,normal_static_ticket_data,0x30);
}
tik.h
+2 -8
View File
@@ -11,6 +11,7 @@ static const unsigned char normal_static_ticket_data[0x30] =
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
};
/*
static const unsigned char system_static_ticket_data[0x30] =
{
0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAC,
@@ -20,7 +21,7 @@ static const unsigned char system_static_ticket_data[0x30] =
0x00, 0x00, 0x00, 0x84, 0x00, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
};
*/
typedef enum
{
lic_Permanent = 0,
@@ -41,13 +42,6 @@ typedef enum
right_AccessTitle = 5
} ticket_item_rights;
typedef enum
{
tik_normal = 1,
tik_system,
tik_test
} cia_type;
typedef struct
{
u8 sig_type[4];
usersettings.c
+89 -85
View File
@@ -36,13 +36,13 @@ int ParseArgs(int argc, char *argv[], user_settings *usr_settings)
}
memset(usr_settings->ContentPath,0,CIA_MAX_CONTENT*sizeof(char*));
// Initialise Keys
InitKeys(&usr_settings->keys);
// Setting Defaults
SetDefaults(usr_settings);
// Initialise Keys
InitKeys(&usr_settings->keys);
// Reading Arguments
// Parsing Arguments
int set_result;
int i = 1;
while(i < argc){
@@ -54,9 +54,13 @@ int ParseArgs(int argc, char *argv[], user_settings *usr_settings)
i += set_result;
}
// Checking arguments
set_result = CheckArgumentCombination(usr_settings);
if(set_result) return set_result;
// Setting Keys
SetKeys(&usr_settings->keys);
if(!usr_settings->outfile){
char *source_path = NULL;
if(usr_settings->IsBuildingNCCH0) source_path = usr_settings->rsf_path;
@@ -77,17 +81,21 @@ int ParseArgs(int argc, char *argv[], user_settings *usr_settings)
void SetDefaults(user_settings *set)
{
// Target Info
set->keys.keyset = keyset_RETAIL;
// Build NCCH Info
set->IsBuildingNCCH0 = true;
#ifdef RETAIL_FSIGN
set->accessdesc = auto_gen;
#else
set->accessdesc = use_spec_file;
#endif
set->include_exefs_logo = false;
set->out_format = CXI;
set->build_ncch_type = format_not_set;
// Yaml Settings
set->yaml_set.Option.EnableCompress = true;
set->yaml_set.Option.EnableCrypt = true;
set->yaml_set.Option.UseOnSD = false;
set->yaml_set.Option.FreeProductCode = false;
// Content0 Info
set->Content0IsNcch = true;
set->ConvertCci = false;
@@ -100,7 +108,7 @@ void SetDefaults(user_settings *set)
set->OmitImportedNcchHdr = false;
// CIA Info
set->EncryptContents = false;
set->EncryptContents = true;
set->RandomTitleKey = false;
for(int i = 0; i < CIA_MAX_CONTENT; i++){
set->ContentID[i] = 0x100000000;
@@ -114,7 +122,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
if(!IsLastArg){
if(argv[i+1][0] != '-') HasParam = true;
}
if(strcmp(argv[i],"-elf") == 0){
if(!HasParam){
PrintNeedsParam("-elf");
@@ -164,7 +171,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->outfile_mallocd = false;
return 2;
}
#ifdef PRIVATE_BUILD
else if(strcmp(argv[i],"-exheader") == 0){
if(!HasParam){
PrintNeedsParam("-exheader");
@@ -197,6 +203,21 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->plain_region_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-target") == 0){
if(!HasParam){
PrintNeedsParam("-target");
return USR_ARG_REQ_PARAM;
}
if(strcasecmp(argv[i+1],"debug") == 0 || strcasecmp(argv[i+1],"dev") == 0)
set->keys.keyset = keyset_DEBUG;
else if(strcasecmp(argv[i+1],"retail") == 0 || strcasecmp(argv[i+1],"prod") == 0)
set->keys.keyset = keyset_RETAIL;
else{
fprintf(stderr,"[SETTING ERROR] Unrecognised target '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
return 2;
}
else if(strcmp(argv[i],"-cci") == 0){
if(!HasParam){
PrintNeedsParam("-cci");
@@ -240,7 +261,15 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->OmitImportedNcchHdr = true;
return 1;
}
#endif
else if(strcmp(argv[i],"-cfa") == 0){
if(HasParam){
PrintNoNeedParam("-cfa");
return USR_ARG_REQ_PARAM;
}
set->build_ncch_type = CFA;
return 1;
}
else if(strcmp(argv[i],"-f") == 0){
if(!HasParam){
PrintNeedsParam("-f");
@@ -256,20 +285,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
}
return 2;
}
else if(strcmp(argv[i],"-ncch") == 0){
if(!HasParam){
PrintNeedsParam("-ncch");
return USR_ARG_REQ_PARAM;
}
if(strcasecmp(argv[i+1],"cxi") == 0) set->build_ncch_type = CXI;
else if(strcasecmp(argv[i+1],"cfa") == 0) set->build_ncch_type = CFA;
else {
fprintf(stderr,"[-] Invalid ncch type '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
return 2;
}
#ifdef RETAIL_FSIGN
else if(strcmp(argv[i],"-sysfixedkey") == 0){
if(!HasParam){
PrintNeedsParam("-sysfixedkey");
@@ -315,24 +330,38 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
free(key);
return 2;
}
#endif
else if(strcmp(argv[i],"-accessdesc") == 0){
if(!HasParam){
PrintNeedsParam("-accessdesc");
return USR_ARG_REQ_PARAM;
}
if(strcasecmp(argv[i+1],"UseRsf") == 0) set->accessdesc = use_spec_file;
else if(strcasecmp(argv[i+1],"AutoGen") == 0 || strcasecmp(argv[i+1],"Auto") == 0) set->accessdesc = auto_gen;
#ifndef RETAIL_FSIGN
else if(strcasecmp(argv[i+1],"App") == 0) set->accessdesc = app;
else if(strcasecmp(argv[i+1],"Demo") == 0) set->accessdesc = demo;
else if(strcasecmp(argv[i+1],"DlpChild") == 0 || strcasecmp(argv[i+1],"Dlp") == 0) set->accessdesc = dlp;
#endif
char *tmp = argv[i+1];
char *tmp2 = strstr(tmp,":");
if(!tmp2){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -accessdesc <APP TYPE>:<TARGET FIRMWARE>\n");
}
if(strlen(tmp2) < 2){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -accessdesc <APP TYPE>:<TARGET FIRMWARE>\n");
}
u32 app_type_len = (u32)(tmp2-tmp);
char *app_type = malloc(app_type_len+1);
memset(app_type,0,app_type_len+1);
memcpy(app_type,tmp,app_type_len);
if(strcasecmp(app_type,"App") == 0 || strcasecmp(app_type,"SDApp") == 0) set->keys.AccessDescSign.PresetType = app;
else if(strcasecmp(app_type,"Demo") == 0) set->keys.AccessDescSign.PresetType = demo;
else if(strcasecmp(app_type,"DlpChild") == 0 || strcasecmp(app_type,"Dlp") == 0) set->keys.AccessDescSign.PresetType = dlp;
else{
fprintf(stderr,"[-] Accessdesc pre-set '%s' not recognised\n",argv[i+1]);
fprintf(stderr,"[SETTING ERROR] Accessdesc AppType preset '%s' not valid, please manually configure RSF\n",app_type);
return USR_BAD_ARG;
}
char *target_firmware = (tmp2+1);
set->keys.AccessDescSign.TargetFirmware = strtoul(target_firmware,NULL,10);
return 2;
}
@@ -352,12 +381,12 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->RandomTitleKey = true;
return 1;
}
else if(strcmp(argv[i],"-encryptcia") == 0){
else if(strcmp(argv[i],"-nocryptcia") == 0){
if(HasParam){
PrintNoNeedParam("-encryptcia");
PrintNoNeedParam("-nocryptcia");
return USR_BAD_ARG;
}
set->EncryptContents = true;
set->EncryptContents = false;
return 1;
}
else if(strcmp(argv[i],"-major") == 0){
@@ -525,31 +554,6 @@ int CheckArgumentCombination(user_settings *set)
return 0;
}
void InvalidateRSFBooleans(rsf_settings *rsf_set)
{
rsf_set->Option.NoPadding = -1;
rsf_set->Option.AllowUnalignedSection = -1;
rsf_set->Option.EnableCrypt = -1;
rsf_set->Option.EnableCompress = -1;
rsf_set->Option.FreeProductCode = -1;
rsf_set->Option.UseOnSD = -1;
rsf_set->AccessControlInfo.DisableDebug = -1;
rsf_set->AccessControlInfo.EnableForceDebug = -1;
rsf_set->AccessControlInfo.CanWriteSharedPage = -1;
rsf_set->AccessControlInfo.CanUsePrivilegedPriority = -1;
rsf_set->AccessControlInfo.CanUseNonAlphabetAndNumber = -1;
rsf_set->AccessControlInfo.PermitMainFunctionArgument = -1;
rsf_set->AccessControlInfo.CanShareDeviceMemory = -1;
rsf_set->AccessControlInfo.UseOtherVariationSaveData = -1;
rsf_set->AccessControlInfo.UseExtSaveData = -1;
rsf_set->AccessControlInfo.UseExtendedSaveDataAccessControl = -1;
rsf_set->AccessControlInfo.RunnableOnSleep = -1;
rsf_set->AccessControlInfo.SpecialMemoryArrange = -1;
rsf_set->BasicInfo.MediaFootPadding = -1;
}
void init_UserSettings(user_settings *usr_settings)
{
memset(usr_settings,0,sizeof(user_settings));
@@ -791,43 +795,46 @@ void PrintNoNeedParam(char *arg)
void DisplayHelp(char *app_name)
{
printf("CTR MAKEROM %d.%d",MAKEROM_VER_MAJOR,MAKEROM_VER_MINOR);
#ifdef PRIVATE_BUILD
#ifndef PUBLIC_BUILD
printf(" PRIVATE BUILD");
#endif
printf("\n(C) 3DSGuy 2014\n");
printf("Usage: %s [options... ]\n",app_name);
printf("Option Parameter Explanation\n");
printf("Global Options:\n");
printf("GLOBAL OPTIONS:\n");
printf(" -help Display this text\n");
printf(" -rsf <rsf path> RSF File\n");
printf(" -f <out format> Output Format (cxi|cfa|cci|cia)\n");
printf(" -o <outfile> Output File\n");
//printf(" -v Verbose\n");
//printf(" -DNAME=VALUE Substitute values in Spec files\n");
printf("NCCH Options:\n");
printf(" -ncch0 <ncch format> NCCH Format (cxi|cfa)\n");
printf("KEY OPTIONS:\n");
printf(" -sysfixedkey <32 hex chars> Specify SystemFixed Key\n");
printf(" -commonkey <32 hex chars> <id> Specify commonkey and index\n");
#ifndef PUBLIC_BUILD
printf(" -target <value> Debug or Retail(Default)\n");
#endif
printf("NCCH OPTIONS:\n");
printf(" -elf <elf path> ELF File\n");
printf(" -icon <icon path> Icon File\n");
printf(" -banner <banner path> Banner File\n");
printf(" -logo <logo path> Logo File\n");
printf(" -exefslogo Include Logo in ExeFs\n");
printf(" -accessdesc <accessdesc type> (AutoGen|UseRsf)\n");
#ifdef RETAIL_FSIGN
printf(" -sysfixedkey <32 hex chars> Specify SystemFixed Key\n");
#endif
#ifdef PRIVATE_BUILD
printf(" -logo <logo path> Logo File (Overrides \"BasicInfo/Logo\" in RSF)\n");
printf(" -accessdesc <apptype>:<fw> Specify AccessDesc Preset\n");
printf(" -exefslogo Include Logo in ExeFs (Required for usage on <5.X Systems)\n");
printf(" -cfa Specify if building a Data Archive when \"-f cia\"\n");
printf("NCCH REBUILD OPTIONS:\n");
printf(" -code <code path> Specify ExeFs code File\n");
printf(" -exheader <exhdr path> ExHeader Template File\n");
printf(" -plain-region <pln region path> PlainRegion File\n");
printf(" -romfs <romfs path> RomFS File\n");
#endif
printf("CCI Options:\n");
#ifdef PRIVATE_BUILD
printf("CCI OPTIONS:\n");
#ifndef PUBLIC_BUILD
printf(" -devcardcci Use SDK CardInfo Method\n");
printf(" -omitncchhdr Omit NCCH Hdr for imported NCCH0\n");
#endif
printf(" -content <filepath>:<index> Specify content files\n");
printf("CIA Options:\n");
#ifdef PRIVATE_BUILD
printf("CIA OPTIONS:\n");
#ifndef PUBLIC_BUILD
printf(" -cci <cci path> Convert CCI to CIA\n");
printf(" -srl <srl path> Use TWL SRL as Content0\n");
#endif
@@ -836,8 +843,5 @@ void DisplayHelp(char *app_name)
printf(" -minor <version minor> Specify Title Version Minor\n");
printf(" -micro <version micro> Specify Title Version Micro\n");
printf(" -rand Use a random title key\n");
printf(" -encryptcia Encrypt CIA Contents\n");
#ifdef RETAIL_FSIGN
printf(" -commonkey <32 hex chars> <id> Specify commonkey and index\n");
#endif
printf(" -nocryptcia Don't encrypt CIA contents\n");
}
usersettings.h
+22 -33
View File
@@ -15,15 +15,6 @@ typedef enum
USR_MEM_ERROR = -6,
} user_settings_errors;
typedef enum
{
auto_gen,
use_spec_file,
app,
demo,
dlp,
} fixed_accessdesc_type;
typedef enum
{
format_not_set,
@@ -39,12 +30,12 @@ typedef struct
{
struct{
// Booleans
int NoPadding;
int AllowUnalignedSection;
int EnableCrypt;
int EnableCompress;
int FreeProductCode;
int UseOnSD;
bool NoPadding; // DELETE
bool AllowUnalignedSection;
bool EnableCrypt;
bool EnableCompress;
bool FreeProductCode;
bool UseOnSD;
// Strings
char *PageSize;
@@ -56,18 +47,18 @@ typedef struct
struct{
// Booleans
int DisableDebug;
int EnableForceDebug;
int CanWriteSharedPage;
int CanUsePrivilegedPriority;
int CanUseNonAlphabetAndNumber;
int PermitMainFunctionArgument;
int CanShareDeviceMemory;
int UseOtherVariationSaveData;
int UseExtSaveData;
int UseExtendedSaveDataAccessControl;
int RunnableOnSleep;
int SpecialMemoryArrange;
bool DisableDebug;
bool EnableForceDebug;
bool CanWriteSharedPage;
bool CanUsePrivilegedPriority;
bool CanUseNonAlphabetAndNumber;
bool PermitMainFunctionArgument;
bool CanShareDeviceMemory;
bool UseOtherVariationSaveData;
bool UseExtSaveData;
bool UseExtendedSaveDataAccessControl;
bool RunnableOnSleep;
bool SpecialMemoryArrange;
// Strings
char *ProgramId; // DELETE
@@ -127,7 +118,7 @@ typedef struct
struct{
// Booleans
int MediaFootPadding;
bool MediaFootPadding;
// Strings
char *Title;
@@ -136,8 +127,8 @@ typedef struct
char *MediaSize;
char *ContentType;
char *Logo;
char *BackupMemoryType;
char *InitialCode;
char *BackupMemoryType;// Delete
char *InitialCode;// Delete
} BasicInfo;
struct{
@@ -171,7 +162,7 @@ typedef struct
struct{
// Strings
char *Platform;
char *Platform; // DELETE
char *Category;
char *UniqueId;
char *Version;
@@ -240,7 +231,6 @@ typedef struct
char *banner_path;
char *logo_path;
fixed_accessdesc_type accessdesc;
bool include_exefs_logo;
char *exefs_code_path;
@@ -272,5 +262,4 @@ void free_UserSettings(user_settings *usr_settings);
int ParseArgs(int argc, char *argv[], user_settings *usr_settings);
void ReadYAMLtest(char *filepath);
void InvalidateRSFBooleans(rsf_settings *rsf_set);
void free_RsfSettings(rsf_settings *set);
yaml_ctr.c
-1
View File
@@ -12,7 +12,6 @@ void BadYamlFormatting(void);
int GetYamlSettings(user_settings *set)
{
memset(&set->yaml_set,0,sizeof(rsf_settings));
InvalidateRSFBooleans(&set->yaml_set);
int ret = 0;
if(set->rsf_path) {
FILE *tmp = fopen(set->rsf_path,"rb");
yamlsettings.c
+12 -12
View File
@@ -52,14 +52,14 @@ void GET_Option(ctr_yaml_context *ctx, rsf_settings *rsf)
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("NoPadding",ctx)) rsf->Option.NoPadding = SetBoolYAMLValue("NoPadding",ctx);
else if(cmpYamlValue("AllowUnalignedSection",ctx)) rsf->Option.AllowUnalignedSection = SetBoolYAMLValue("AllowUnalignedSection",ctx);
if(cmpYamlValue("AllowUnalignedSection",ctx)) rsf->Option.AllowUnalignedSection = SetBoolYAMLValue("AllowUnalignedSection",ctx);
//else if(cmpYamlValue("NoPadding",ctx)) rsf->Option.NoPadding = SetBoolYAMLValue("NoPadding",ctx);
else if(cmpYamlValue("EnableCrypt",ctx)) rsf->Option.EnableCrypt = SetBoolYAMLValue("EnableCrypt",ctx);
else if(cmpYamlValue("EnableCompress",ctx)) rsf->Option.EnableCompress = SetBoolYAMLValue("EnableCompress",ctx);
else if(cmpYamlValue("FreeProductCode",ctx)) rsf->Option.FreeProductCode = SetBoolYAMLValue("FreeProductCode",ctx);
else if(cmpYamlValue("UseOnSD",ctx)) rsf->Option.UseOnSD = SetBoolYAMLValue("UseOnSD",ctx);
else if(cmpYamlValue("PageSize",ctx)) SetSimpleYAMLValue(&rsf->Option.PageSize,"PageSize",ctx,0);
else if(cmpYamlValue("AppendSystemCall",ctx)) rsf->Option.AppendSystemCallNum = SetYAMLSequence(&rsf->Option.AppendSystemCall,"AppendSystemCall",ctx);
//else if(cmpYamlValue("AppendSystemCall",ctx)) rsf->Option.AppendSystemCallNum = SetYAMLSequence(&rsf->Option.AppendSystemCall,"AppendSystemCall",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
@@ -97,7 +97,7 @@ void GET_AccessControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
else if(cmpYamlValue("SpecialMemoryArrange",ctx)) rsf->AccessControlInfo.SpecialMemoryArrange = SetBoolYAMLValue("SpecialMemoryArrange",ctx);
else if(cmpYamlValue("ProgramId",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ProgramId,"ProgramId",ctx,0);
//else if(cmpYamlValue("ProgramId",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ProgramId,"ProgramId",ctx,0);
else if(cmpYamlValue("IdealProcessor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.IdealProcessor,"IdealProcessor",ctx,0);
else if(cmpYamlValue("Priority",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.Priority,"Priority",ctx,0);
else if(cmpYamlValue("MemoryType",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.MemoryType,"MemoryType",ctx,0);
@@ -112,7 +112,7 @@ void GET_AccessControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
else if(cmpYamlValue("ExtSaveDataId",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ExtSaveDataId,"ExtSaveDataId",ctx,0);
else if(cmpYamlValue("AffinityMask",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.AffinityMask,"AffinityMask",ctx,0);
else if(cmpYamlValue("DescVersion",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.DescVersion,"DescVersion",ctx,0);
else if(cmpYamlValue("CryptoKey",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.CryptoKey,"CryptoKey",ctx,0);
//else if(cmpYamlValue("CryptoKey",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.CryptoKey,"CryptoKey",ctx,0);
else if(cmpYamlValue("ResourceLimitCategory",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ResourceLimitCategory,"ResourceLimitCategory",ctx,0);
else if(cmpYamlValue("ReleaseKernelMajor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ReleaseKernelMajor,"ReleaseKernelMajor",ctx,0);
else if(cmpYamlValue("ReleaseKernelMinor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ReleaseKernelMinor,"ReleaseKernelMinor",ctx,0);
@@ -126,7 +126,7 @@ void GET_AccessControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
else if(cmpYamlValue("InterruptNumbers",ctx)) rsf->AccessControlInfo.InterruptNumbersNum = SetYAMLSequence(&rsf->AccessControlInfo.InterruptNumbers,"InterruptNumbers",ctx);
else if(cmpYamlValue("SystemCallAccess",ctx)) rsf->AccessControlInfo.SystemCallAccessNum = SetYAMLSequenceFromMapping(&rsf->AccessControlInfo.SystemCallAccess,"SystemCallAccess",ctx,false);
else if(cmpYamlValue("ServiceAccessControl",ctx)) rsf->AccessControlInfo.ServiceAccessControlNum = SetYAMLSequence(&rsf->AccessControlInfo.ServiceAccessControl,"ServiceAccessControl",ctx);
else if(cmpYamlValue("StorageId",ctx)) rsf->AccessControlInfo.StorageIdNum = SetYAMLSequence(&rsf->AccessControlInfo.StorageId,"StorageId",ctx);
//else if(cmpYamlValue("StorageId",ctx)) rsf->AccessControlInfo.StorageIdNum = SetYAMLSequence(&rsf->AccessControlInfo.StorageId,"StorageId",ctx);
else if(cmpYamlValue("AccessibleSaveDataIds",ctx)) rsf->AccessControlInfo.AccessibleSaveDataIdsNum = SetYAMLSequence(&rsf->AccessControlInfo.AccessibleSaveDataIds,"AccessibleSaveDataIds",ctx);
else{
@@ -188,8 +188,8 @@ void GET_BasicInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
else if(cmpYamlValue("MediaSize",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.MediaSize,"MediaSize",ctx,0);
else if(cmpYamlValue("ContentType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.ContentType,"ContentType",ctx,0);
else if(cmpYamlValue("Logo",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.Logo,"Logo",ctx,0);
else if(cmpYamlValue("BackupMemoryType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.BackupMemoryType,"BackupMemoryType",ctx,0);
else if(cmpYamlValue("InitialCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.InitialCode,"InitialCode",ctx,0);
//else if(cmpYamlValue("BackupMemoryType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.BackupMemoryType,"BackupMemoryType",ctx,0);
//else if(cmpYamlValue("InitialCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.InitialCode,"InitialCode",ctx,0);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
@@ -215,7 +215,7 @@ void GET_Rom(ctr_yaml_context *ctx, rsf_settings *rsf)
// Handle childs
if(cmpYamlValue("HostRoot",ctx)) SetSimpleYAMLValue(&rsf->Rom.HostRoot,"HostRoot",ctx,0);
else if(cmpYamlValue("Padding",ctx)) SetSimpleYAMLValue(&rsf->Rom.Padding,"Padding",ctx,0);
//else if(cmpYamlValue("Padding",ctx)) SetSimpleYAMLValue(&rsf->Rom.Padding,"Padding",ctx,0);
else if(cmpYamlValue("SaveDataSize",ctx)) SetSimpleYAMLValue(&rsf->Rom.SaveDataSize,"SaveDataSize",ctx,0);
else if(cmpYamlValue("DefaultReject",ctx)) rsf->Rom.DefaultRejectNum = SetYAMLSequence(&rsf->Rom.DefaultReject,"DefaultReject",ctx);
@@ -280,13 +280,13 @@ void GET_TitleInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("Platform",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Platform,"Platform",ctx,0);
else if(cmpYamlValue("Category",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Category,"Category",ctx,0);
if(cmpYamlValue("Category",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Category,"Category",ctx,0);
//else if(cmpYamlValue("Platform",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Platform,"Platform",ctx,0);
else if(cmpYamlValue("UniqueId",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.UniqueId,"UniqueId",ctx,0);
else if(cmpYamlValue("Version",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Version,"Version",ctx,0);
else if(cmpYamlValue("ContentsIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ContentsIndex,"ContentsIndex",ctx,0);
else if(cmpYamlValue("Variation",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Variation,"Variation",ctx,0);
else if(cmpYamlValue("Use",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Use,"Use",ctx,0);
//else if(cmpYamlValue("Use",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Use,"Use",ctx,0);
else if(cmpYamlValue("ChildIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ChildIndex,"ChildIndex",ctx,0);
else if(cmpYamlValue("DemoIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.DemoIndex,"DemoIndex",ctx,0);
else if(cmpYamlValue("TargetCategory",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.TargetCategory,"TargetCategory",ctx,0);