DarkStore-3DS/Project_CTR
1
0
Fork 0
mirror of https://github.com/DarkStore-3DS/Project_CTR.git synced 2026-07-06 08:49:04 +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 # Default value for application
BasicInfo: BasicInfo:
Title : "Pyramids" Title : "Homebrew"
CompanyCode : "00" 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 ContentType : Application # Application / SystemUpdate / Manual / Child / Trial
Logo : Licensed # Nintendo / Licensed / Distributed / iQue / iQueForSystem Logo : Licensed # Nintendo / Licensed / Distributed
BackupMemoryType: None # None / 128KB / 512KB 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: TitleInfo:
UniqueId: 0xff3ff
#TargetCategory: Contents
Category: Application 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: Option:
UseOnSD: true # true if App is to be installed to SD UseOnSD: true # true if App is to be installed to SD
EnableCompress: true EnableCompress: true
FreeProductCode: true FreeProductCode: true
EnableCrypt : true EnableCrypt : false
Rom:
SaveDataSize: 128KB
ExeFs: ExeFs:
ReadOnly: ReadOnly:
- .rodata - .rodata
#- RO - RO
ReadWrite: ReadWrite:
- .data - .data
#- RW - RO
Text: Text:
- .text - .text
#- STUP_ENTRY - STUP_ENTRY
PlainRegion:
- .module_id
# Don't Modify Below here AccessControlInfo:
AccessControlInfo: MaxCpu: 0x0 # 0x9E
MaxCpu: 0x9E DisableDebug : true
AffinityMask: 1 EnableForceDebug : true
CoreVersion: 2 CanWriteSharedPage : true
DescVersion: 2 CanUsePrivilegedPriority : true
HandleTableSize: 512 CanUseNonAlphabetAndNumber : true
IORegisterMapping: PermitMainFunctionArgument : true
- 1ff50000-1ff57fff CanShareDeviceMemory : true
- 1ff70000-1ff77fff #UseOtherVariationSaveData : true
IdealProcessor: 0 #UseExtSaveData : true
MemoryMapping: RunnableOnSleep : true
- 1f000000-1f5fffff:r SpecialMemoryArrange : true
Priority: 16 #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: InterruptNumbers:
- 0x1
AffinityMask: 1
DescVersion: 2
DisableDebug: false
SystemCallAccess: SystemCallAccess:
ArbitrateAddress: 34 ArbitrateAddress: 34
Break: 60 Break: 60
@@ -98,9 +158,18 @@ AccessControlInfo:
UnmapMemoryBlock: 32 UnmapMemoryBlock: 32
WaitSynchronization1: 36 WaitSynchronization1: 36
WaitSynchronizationN: 37 WaitSynchronizationN: 37
HandleTableSize: 512
IORegisterMapping:
- 1ff50000-1ff57fff
- 1ff70000-1ff77fff
IdealProcessor: 0
MemoryMapping:
- 1f000000-1f5fffff:r
MemoryType: Application MemoryType: Application
Priority: 16
ProgramId: 0x00040000ffffff00L
ReleaseKernelMajor: "02" ReleaseKernelMajor: "02"
ReleaseKernelMinor: "33" ReleaseKernelMinor: "33"
ServiceAccessControl: ServiceAccessControl:
- APT:U - APT:U
- $hioFIO - $hioFIO
@@ -130,8 +199,12 @@ AccessControlInfo:
- y2r:u - y2r:u
- ldr:ro - ldr:ro
- ir:USER - ir:USER
CoreVersion: 2
SystemControlInfo: StorageId:
- 0
SystemControlInfo:
RemasterVersion: 5
Dependency: Dependency:
ac: 0x0004013000002402L ac: 0x0004013000002402L
am: 0x0004013000001502L am: 0x0004013000001502L
@@ -164,8 +237,8 @@ SystemControlInfo:
spi: 0x0004013000002302L spi: 0x0004013000002302L
ssl: 0x0004013000002f02L ssl: 0x0004013000002f02L
StackSize: 0x40000 StackSize: 0x40000
CommonHeaderKey: CommonHeaderKey:
D: | D: |
jL2yO86eUQnYbXIrzgFVMm7FVze0LglZ2f5g+c42hWoEdnb5BOotaMQPBfqt jL2yO86eUQnYbXIrzgFVMm7FVze0LglZ2f5g+c42hWoEdnb5BOotaMQPBfqt
aUyAEmzQPaoi/4l4V+hTJRXQfthVRqIEx27B84l8LA6Tl5Fy9PaQaQ+4yRfP aUyAEmzQPaoi/4l4V+hTJRXQfthVRqIEx27B84l8LA6Tl5Fy9PaQaQ+4yRfP
@@ -173,6 +246,20 @@ CommonHeaderKey:
0RCb66lYcr2h/p2G7SnpKUliS9h9KnpmG+UEgVYQUK+4SCfByUa9PxYGpT0E 0RCb66lYcr2h/p2G7SnpKUliS9h9KnpmG+UEgVYQUK+4SCfByUa9PxYGpT0E
nw1UcRz0gsBmdOqcgzwnAd9vVqgb42hVn6uQZyAl+j1RKiMWywZarazIR/k5 nw1UcRz0gsBmdOqcgzwnAd9vVqgb42hVn6uQZyAl+j1RKiMWywZarazIR/k5
Lmr4+groimSEa+3ajyoIho9WaWTDmFU3mkhA2tUDIQ== 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: | Modulus: |
z+yySANtuAnjXGxiLKlJ4fT0DGzD5S+dUKArWgDGcgALowRdlEbnABtIhbVh z+yySANtuAnjXGxiLKlJ4fT0DGzD5S+dUKArWgDGcgALowRdlEbnABtIhbVh
LMl0yitDE8F4l1wzLwfHhfDa22CWUA98S3rXF53k5cOrb12leDKtBN2Wbtx1 LMl0yitDE8F4l1wzLwfHhfDa22CWUA98S3rXF53k5cOrb12leDKtBN2Wbtx1
@@ -180,6 +267,14 @@ CommonHeaderKey:
BEou29fQZEOc0HgRQYgz3TFikC0X8sapK5xwq9zTq13a7j1sDoH/9mdaRPms BEou29fQZEOc0HgRQYgz3TFikC0X8sapK5xwq9zTq13a7j1sDoH/9mdaRPms
Bz0jlHVlkyAMxXYdD2UGPSGi8JaAtwpJUzijXcB0PKTZQDaFH4zRLRX57ySp Bz0jlHVlkyAMxXYdD2UGPSGi8JaAtwpJUzijXcB0PKTZQDaFH4zRLRX57ySp
fp2yHvigcoEXd3OxVn+tBaLSMFr1068PEEpS2AlHlw== fp2yHvigcoEXd3OxVn+tBaLSMFr1068PEEpS2AlHlw==
P: |
6SdD3AiAybNamgUgGJduyFWO1/LeakmoJm+23IEJADyU4nz+reGjxQnMrR+x
syuB8VPGuf1z0SInfRIu9PEjIfW9/H/fZ59GwckQuJbneODjW7KU1jM3cTVX
+AWvaxWDwlCUmVSYD2OySUJlo3szGmBYh/o/tKAq7kElaaOt+cc=
Q: |
5EyO8bCyfqgLTfipAG/nNLObQbqMyARdQfudxh4eQqHmzblEM3jareuA8eUZ
K8pIaP+U9UfxwWTeFsOulrpsm04j4gS71WGNx3YwOIRPXXOn7zBkxA3AO9qq
K8lMeV3gNsdt4Fz8Zh2F68HSP4avB+ThO2S18SXMyIkcM7Sbw7E=
Signature: | Signature: |
3xyLmORvojVswxgXmPPOVH4ULn8e2G3PvClO/jIuwRGtRprGcOruKFUi4TYF 3xyLmORvojVswxgXmPPOVH4ULn8e2G3PvClO/jIuwRGtRprGcOruKFUi4TYF
HASKzg8Mg4/I1t4RjurPrZvPgQ3rcROz066DAkwOEFBZPO5gBvuMf8IgJAFi 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 CC = gcc
# MAKEROM Build Settings # MAKEROM Build Settings
MAKEROM_BUILD_FLAGS = -DPRIVATE_BUILD #-DRETAIL_FSIGN #-DELF_DEBUG MAKEROM_BUILD_FLAGS = #-DDEBUG #-DELF_DEBUG
VER_MAJOR = 0 VER_MAJOR = 0
VER_MINOR = 2 VER_MINOR = 3
OUTPUT = makerom OUTPUT = makerom
main: build 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; ciaset->content.content0_FileLen = usrset->Content0.size;
u32_to_u8(ciaset->Title_type,TYPE_CTR,BE); u32_to_u8(ciaset->Title_type,TYPE_CTR,BE);
ciaset->content.EncryptContents = usrset->EncryptContents; 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.ca_crl_version = 0;
ciaset->cert.signer_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.ticket_format_ver = 1;
ciaset->tik.UnknownDataType = tik_normal;
int result = GenCertChildIssuer(ciaset->tik.TicketIssuer,usrset->keys.certs.tik_cert); int result = GenCertChildIssuer(ciaset->tik.TicketIssuer,usrset->keys.certs.tik_cert);
if(result) return result; if(result) return result;
cia.h
-1
View File
@@ -51,7 +51,6 @@ typedef struct
u8 DeviceID[8]; u8 DeviceID[8];
u8 TicketVersion[3]; u8 TicketVersion[3];
u8 TitleKey[16]; u8 TitleKey[16];
u8 UnknownDataType;
} tik; } tik;
struct{ 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; return result;
} }
#ifdef DEBUG
printf("[DEBUG] Import ELF\n");
#endif
/* Import ELF */ /* Import ELF */
u8 *ElfFile = malloc(ncchset->ComponentFilePtrs.elf_size); u8 *ElfFile = malloc(ncchset->ComponentFilePtrs.elf_size);
if(!ElfFile) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;} if(!ElfFile) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ElfFile,ncchset->ComponentFilePtrs.elf_size,0,ncchset->ComponentFilePtrs.elf); ReadFile_64(ElfFile,ncchset->ComponentFilePtrs.elf_size,0,ncchset->ComponentFilePtrs.elf);
#ifdef DEBUG
printf("[DEBUG] Create ELF Context\n");
#endif
/* Create ELF Context */ /* Create ELF Context */
ElfContext *elf = malloc(sizeof(ElfContext)); ElfContext *elf = malloc(sizeof(ElfContext));
if(!elf) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); free(ElfFile); return MEM_ERROR;} 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); PrintElfContext(elf,ElfFile);
#endif #endif
#ifdef DEBUG
PrintElfContext(elf,ElfFile);
#endif
#ifdef DEBUG
printf("[DEBUG] Create ExeFs Code\n");
#endif
result = CreateExeFsCode(elf,ElfFile,ncchset); result = CreateExeFsCode(elf,ElfFile,ncchset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Get BSS Size\n");
#endif
result = GetBSS_SizeFromElf(elf,ElfFile,ncchset); result = GetBSS_SizeFromElf(elf,ElfFile,ncchset);
if(result) goto finish; 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 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); 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++){ 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); free(elf->Segments[i].Sections);
} }
#ifdef DEBUG
printf("[DEBUG] Free others\n");
#endif
free(ElfFile); free(ElfFile);
free(elf->Sections); free(elf->Sections);
free(elf->ProgramHeaders); free(elf->ProgramHeaders);
exheader.c
+350 -197
View File
@@ -5,9 +5,7 @@
#include "titleid.h" #include "titleid.h"
#include "polarssl/base64.h" #include "polarssl/base64.h"
#ifndef RETAIL_FSIGN
#include "accessdesc_sig.h" // For AccessDesc Presets #include "accessdesc_sig.h" // For AccessDesc Presets
#endif
/* Prototypes */ /* Prototypes */
void init_ExHeaderSettings(exheader_settings *exhdrset); 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_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *ncchset);
int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset); int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset);
void AdjustBooleans(rsf_settings *yaml);
int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *yaml); int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *yaml);
int get_ExHeaderDependencyList(u8 *DependencyList, rsf_settings *yaml); int get_ExHeaderDependencyList(u8 *DependencyList, rsf_settings *yaml);
int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, 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 SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml);
int GetAppType(int *AppType, rsf_settings *yaml); int GetAppType(int *AppType, rsf_settings *yaml);
int SetARM11ResLimitDesc(exhdr_ARM11SystemLocalCapabilities *arm11, 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); u32 GetDescPrefixBits(int numPrefixBits, u32 PrefixVal);
int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_settings *yaml); int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_settings *yaml);
int set_AccessDesc(exheader_settings *exhdrset, ncch_settings *ncchset); 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 */ /* ExHeader Signature Functions */
int SignAccessDesc(ExtendedHeader_Struct *ExHdr, keys_struct *keys) int SignAccessDesc(ExtendedHeader_Struct *ExHdr, keys_struct *keys)
@@ -90,6 +90,9 @@ int BuildExHeader(ncch_settings *ncchset)
result = set_AccessDesc(exhdrset,ncchset); result = set_AccessDesc(exhdrset,ncchset);
if(result) goto finish; if(result) goto finish;
exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities.Flags[6] = 5;
finish: finish:
if(result) fprintf(stderr,"[EXHEADER ERROR] Failed to create ExHeader\n"); if(result) fprintf(stderr,"[EXHEADER ERROR] Failed to create ExHeader\n");
free_ExHeaderSettings(exhdrset); free_ExHeaderSettings(exhdrset);
@@ -112,6 +115,7 @@ int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *
/* Transfer settings */ /* Transfer settings */
exhdrset->keys = ncchset->keys; exhdrset->keys = ncchset->keys;
exhdrset->yaml = ncchset->yaml_set; exhdrset->yaml = ncchset->yaml_set;
exhdrset->UseAccessDescPreset = ncchset->keys->AccessDescSign.PresetType != not_preset;
/* Creating Output Buffer */ /* Creating Output Buffer */
ncchset->Sections.ExHeader.size = 0x800; 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;} 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); memset(ncchset->Sections.ExHeader.buffer,0,ncchset->Sections.ExHeader.size);
/* Import ExHeader template */ /* Import ExHeader Code Section template */
if(ncchset->ComponentFilePtrs.exheader_size){ if(ncchset->ComponentFilePtrs.exheader_size){
u32 import_size = min_u64(0x40,ncchset->ComponentFilePtrs.exheader_size); u32 import_size = 0x30; min_u64(0x30,ncchset->ComponentFilePtrs.exheader_size);
ReadFile_64(ncchset->Sections.ExHeader.buffer,import_size,0,ncchset->ComponentFilePtrs.exheader); 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 */ /* Create ExHeader Struct for output */
@@ -152,54 +160,40 @@ int get_ExHeaderSettingsFromNcchset(exheader_settings *exhdrset, ncch_settings *
if(ncchset->Options.UseOnSD) if(ncchset->Options.UseOnSD)
exhdrset->ExHdr->CodeSetInfo.Flags.flag |= RetailSDAppFlag; exhdrset->ExHdr->CodeSetInfo.Flags.flag |= RetailSDAppFlag;
if(!ncchset->Options.UseRomFS) // Move this later 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; return 0;
} }
int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset) int get_ExHeaderSettingsFromYaml(exheader_settings *exhdrset)
{ {
AdjustBooleans(exhdrset->yaml);
int result = 0; int result = 0;
result = get_ExHeaderCodeSetInfo(&exhdrset->ExHdr->CodeSetInfo, exhdrset->yaml); result = get_ExHeaderCodeSetInfo(&exhdrset->ExHdr->CodeSetInfo, exhdrset->yaml);
if(result) goto finish; if(result) goto finish;
result = get_ExHeaderDependencyList((u8*)&exhdrset->ExHdr->DependencyList[0], exhdrset->yaml); if(!exhdrset->UseAccessDescPreset){
if(result) goto finish; result = get_ExHeaderDependencyList((u8*)&exhdrset->ExHdr->DependencyList[0], exhdrset->yaml);
if(result) goto finish;
}
result = get_ExHeaderSystemInfo(&exhdrset->ExHdr->SystemInfo, exhdrset->yaml); result = get_ExHeaderSystemInfo(&exhdrset->ExHdr->SystemInfo, exhdrset->yaml);
if(result) goto finish; 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; if(result) goto finish;
result = get_ExHeaderARM11KernelInfo(&exhdrset->ExHdr->ARM11KernelCapabilities, exhdrset->yaml); if(!exhdrset->UseAccessDescPreset){
if(result) goto finish; result = get_ExHeaderARM11KernelInfo(&exhdrset->ExHdr->ARM11KernelCapabilities, exhdrset->yaml);
if(result) goto finish;
result = get_ExHeaderARM9AccessControlInfo(&exhdrset->ExHdr->ARM9AccessControlInfo, exhdrset->yaml); result = get_ExHeaderARM9AccessControlInfo(&exhdrset->ExHdr->ARM9AccessControlInfo, exhdrset->yaml);
if(result) goto finish; if(result) goto finish;
}
finish: finish:
return result; 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) int get_ExHeaderCodeSetInfo(exhdr_CodeSetInfo *CodeSetInfo, rsf_settings *yaml)
{ {
/* Name */ /* Name */
@@ -256,19 +250,19 @@ int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, rsf_settings *yaml)
if(strstr(yaml->Rom.SaveDataSize,"K")){ if(strstr(yaml->Rom.SaveDataSize,"K")){
char *str = strstr(yaml->Rom.SaveDataSize,"K"); char *str = strstr(yaml->Rom.SaveDataSize,"K");
if(strcmp(str,"K") == 0 || strcmp(str,"KB") == 0 ){ if(strcmp(str,"K") == 0 || strcmp(str,"KB") == 0 ){
SaveDataSize = SaveDataSize*KB; SaveDataSize *= KB;
} }
} }
else if(strstr(yaml->Rom.SaveDataSize,"M")){ else if(strstr(yaml->Rom.SaveDataSize,"M")){
char *str = strstr(yaml->Rom.SaveDataSize,"M"); char *str = strstr(yaml->Rom.SaveDataSize,"M");
if(strcmp(str,"M") == 0 || strcmp(str,"MB") == 0 ){ if(strcmp(str,"M") == 0 || strcmp(str,"MB") == 0 ){
SaveDataSize = SaveDataSize*MB; SaveDataSize *= MB;
} }
} }
else if(strstr(yaml->Rom.SaveDataSize,"G")){ else if(strstr(yaml->Rom.SaveDataSize,"G")){
char *str = strstr(yaml->Rom.SaveDataSize,"G"); char *str = strstr(yaml->Rom.SaveDataSize,"G");
if(strcmp(str,"G") == 0 || strcmp(str,"GB") == 0 ){ if(strcmp(str,"G") == 0 || strcmp(str,"GB") == 0 ){
SaveDataSize = SaveDataSize*GB; SaveDataSize *= GB;
} }
} }
else{ else{
@@ -298,7 +292,7 @@ int get_ExHeaderSystemInfo(exhdr_SystemInfo *SystemInfo, rsf_settings *yaml)
return 0; return 0;
} }
int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml) int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings *yaml, bool UseAccessDescPreset)
{ {
/* Program Id */ /* Program Id */
u64 ProgramId = 0; u64 ProgramId = 0;
@@ -306,30 +300,33 @@ int get_ExHeaderARM11SystemLocalInfo(exhdr_ARM11SystemLocalCapabilities *arm11,
if(result) return result; if(result) return result;
u64_to_u8(arm11->ProgramId,ProgramId,LE); u64_to_u8(arm11->ProgramId,ProgramId,LE);
/* Flags */ if(!UseAccessDescPreset){
result = SetARM11SystemLocalInfoFlags(arm11, yaml); /* Flags */
if(result) return result; result = SetARM11SystemLocalInfoFlags(arm11, yaml);
if(result) return result;
/* Resource Limit Descriptors */ /* Resource Limit Descriptors */
result = SetARM11ResLimitDesc(arm11, yaml); result = SetARM11ResLimitDesc(arm11, yaml);
if(result) return result; if(result) return result;
}
/* Storage Info */ /* Storage Info */
result = SetARM11StorageInfo(arm11, yaml); result = SetARM11StorageInfo(arm11, yaml);
if(result) return result; if(result) return result;
/* Service Access Control */ if(!UseAccessDescPreset){
result = SetARM11ServiceAccessControl(arm11, yaml); /* Service Access Control */
if(result) return result; result = SetARM11ServiceAccessControl(arm11, yaml);
if(result) return result;
/* Resource Limit Category */ /* Resource Limit Category */
if(yaml->AccessControlInfo.ResourceLimitCategory){ if(yaml->AccessControlInfo.ResourceLimitCategory){
if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"application") == 0) arm11->ResourceLimitCategory = resrc_limit_APPLICATION; 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,"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,"libapplet") == 0) arm11->ResourceLimitCategory = resrc_limit_LIB_APPLET;
else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"other") == 0) arm11->ResourceLimitCategory = resrc_limit_OTHER; else if(strcasecmp(yaml->AccessControlInfo.ResourceLimitCategory,"other") == 0) arm11->ResourceLimitCategory = resrc_limit_OTHER;
}
} }
/* Finish */ /* Finish */
return 0; return 0;
} }
@@ -352,14 +349,14 @@ int SetARM11SystemLocalInfoFlags(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_
u8 SystemMode = 0; u8 SystemMode = 0;
if(yaml->AccessControlInfo.AffinityMask){ if(yaml->AccessControlInfo.AffinityMask){
AffinityMask = strtol(yaml->AccessControlInfo.AffinityMask,NULL,0); 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); fprintf(stderr,"[EXHEADER ERROR] Unexpected AffinityMask: %d. Expected range: 0x0 - 0x1\n",AffinityMask);
return EXHDR_BAD_YAML_OPT; return EXHDR_BAD_YAML_OPT;
} }
} }
if(yaml->AccessControlInfo.IdealProcessor){ if(yaml->AccessControlInfo.IdealProcessor){
IdealProcessor = strtol(yaml->AccessControlInfo.IdealProcessor,NULL,0); 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); fprintf(stderr,"[EXHEADER ERROR] Unexpected IdealProcessor: %d. Expected range: 0x0 - 0x1\n",IdealProcessor);
return EXHDR_BAD_YAML_OPT; return EXHDR_BAD_YAML_OPT;
} }
@@ -443,47 +440,47 @@ int SetARM11StorageInfo(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_settings
u32 AccessInfo = 0; u32 AccessInfo = 0;
for(int i = 0; i < yaml->AccessControlInfo.FileSystemAccessNum; i++){ for(int i = 0; i < yaml->AccessControlInfo.FileSystemAccessNum; i++){
if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategorySystemApplication") == 0) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) else if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"CategoryHomeMenu") == 0)
AccessInfo |= 1 << CATEGORY_HOME_MENU; AccessInfo |= 1 << fsaccess_CATEGORY_HOME_MENU;
else{ else{
fprintf(stderr,"[EXHEADER ERROR] Invalid FileSystemAccess Name: '%s'\n",yaml->AccessControlInfo.FileSystemAccess[i]); fprintf(stderr,"[EXHEADER ERROR] Invalid FileSystemAccess Name: '%s'\n",yaml->AccessControlInfo.FileSystemAccess[i]);
return EXHDR_BAD_YAML_OPT; 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"); fprintf(stderr,"[EXHEADER ERROR] Failed to set ExtSaveDataId. UseExtSaveData must be true.\n");
return EXHDR_BAD_YAML_OPT; return EXHDR_BAD_YAML_OPT;
} }
u32 ExtdataIdLow = strtoul(yaml->AccessControlInfo.ExtSaveDataId,NULL,0); u64 ExtdataId = strtoull(yaml->AccessControlInfo.ExtSaveDataId,NULL,0);
u32_to_u8(arm11->StorageInfo.ExtSaveDataId,ExtdataIdLow,LE); u64_to_u8(arm11->StorageInfo.ExtSaveDataId,ExtdataId,LE);
} }
return 0; return 0;
} }
@@ -547,6 +544,13 @@ bool CheckCondiditionsForNewAccessibleSaveDataIds(rsf_settings *yaml)
return false; 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){ if(yaml->AccessControlInfo.AccessibleSaveDataIdsNum > 6){
fprintf(stderr,"[EXHEADER ERROR] Too many UniqueId in \"AccessibleSaveDataIds\".\n"); fprintf(stderr,"[EXHEADER ERROR] Too many UniqueId in \"AccessibleSaveDataIds\".\n");
return false; 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 */ /* UseOtherVariationSaveData Flag */
if(yaml->AccessControlInfo.UseOtherVariationSaveData){ if(yaml->AccessControlInfo.UseOtherVariationSaveData){
@@ -618,20 +622,20 @@ int SetARM11ServiceAccessControl(exhdr_ARM11SystemLocalCapabilities *arm11, rsf_
{ {
if(yaml->AccessControlInfo.ServiceAccessControl){ if(yaml->AccessControlInfo.ServiceAccessControl){
if(yaml->AccessControlInfo.ServiceAccessControlNum > 32){ 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; return EXHDR_BAD_YAML_OPT;
} }
for(int i = 0; i < yaml->AccessControlInfo.ServiceAccessControlNum; i++){ for(int i = 0; i < yaml->AccessControlInfo.ServiceAccessControlNum; i++){
int svc_handle_len = strlen(yaml->AccessControlInfo.ServiceAccessControl[i]); int svc_handle_len = strlen(yaml->AccessControlInfo.ServiceAccessControl[i]);
if(svc_handle_len > 8){ 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; return EXHDR_BAD_YAML_OPT;
} }
memcpy(arm11->ServiceAccessControl[i],yaml->AccessControlInfo.ServiceAccessControl[i],svc_handle_len); memcpy(arm11->ServiceAccessControl[i],yaml->AccessControlInfo.ServiceAccessControl[i],svc_handle_len);
} }
} }
else{ 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 EXHDR_BAD_YAML_OPT;
} }
return 0; return 0;
@@ -866,14 +870,17 @@ int GetARM11IOMappings(ARM11KernelCapabilityDescriptor *desc, rsf_settings *yaml
u16 DescUsed = 0; u16 DescUsed = 0;
for(int i = 0; i < yaml->AccessControlInfo.IORegisterMappingNum; i++){ for(int i = 0; i < yaml->AccessControlInfo.IORegisterMappingNum; i++){
if(strlen(yaml->AccessControlInfo.IORegisterMapping[i])){ if(strlen(yaml->AccessControlInfo.IORegisterMapping[i])){
// Parse Address String
char *AddressStartStr = yaml->AccessControlInfo.IORegisterMapping[i]; char *AddressStartStr = yaml->AccessControlInfo.IORegisterMapping[i];
char *AddressEndStr = strstr(AddressStartStr,"-"); char *AddressEndStr = strstr(AddressStartStr,"-");
if(AddressEndStr){ if(AddressEndStr){
if(strlen(AddressEndStr) > 1) if(strlen(AddressEndStr) > 1) // if not just '-'
AddressEndStr = (AddressEndStr+1); AddressEndStr = (AddressEndStr+1); // Setting the str to the expected start of address string
else else
AddressEndStr = NULL; AddressEndStr = NULL;
} }
u32 AddressStart = strtoul(AddressStartStr,NULL,16); u32 AddressStart = strtoul(AddressStartStr,NULL,16);
if(!IsStartAddress(AddressStart)){ if(!IsStartAddress(AddressStart)){
fprintf(stderr,"[EXHEADER ERROR] Address 0x%x is not valid mapping start address.\n",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) bool IsEndAddress(u32 Address)
{ {
return (Address & 0xfff) == 0xfff; return (Address & 0x0fff) == 0x0fff;
} }
bool IsStartAddress(u32 Address) bool IsStartAddress(u32 Address)
{ {
return (Address & 0xfff) == 0; return (Address & 0x0fff) == 0;
} }
u32 GetIOMappingDesc(u32 Address) u32 GetIOMappingDesc(u32 Address)
@@ -1012,23 +1019,23 @@ int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, r
u32 OtherCapabilities = 0; u32 OtherCapabilities = 0;
if(!yaml->AccessControlInfo.DisableDebug) if(!yaml->AccessControlInfo.DisableDebug)
OtherCapabilities |= 1 << PERMIT_DEBUG; OtherCapabilities |= 1 << othcap_PERMIT_DEBUG;
if(yaml->AccessControlInfo.EnableForceDebug) if(yaml->AccessControlInfo.EnableForceDebug)
OtherCapabilities |= 1 << FORCE_DEBUG; OtherCapabilities |= 1 << othcap_FORCE_DEBUG;
if(yaml->AccessControlInfo.CanUseNonAlphabetAndNumber) 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) if(yaml->AccessControlInfo.CanWriteSharedPage)
OtherCapabilities |= 1 << CAN_WRITE_SHARED_PAGE; OtherCapabilities |= 1 << othcap_CAN_WRITE_SHARED_PAGE;
if(yaml->AccessControlInfo.CanUsePrivilegedPriority) if(yaml->AccessControlInfo.CanUsePrivilegedPriority)
OtherCapabilities |= 1 << CAN_USE_PRIVILEGE_PRIORITY; OtherCapabilities |= 1 << othcap_CAN_USE_PRIVILEGE_PRIORITY;
if(yaml->AccessControlInfo.PermitMainFunctionArgument) if(yaml->AccessControlInfo.PermitMainFunctionArgument)
OtherCapabilities |= 1 << PERMIT_MAIN_FUNCTION_ARGUMENT; OtherCapabilities |= 1 << othcap_PERMIT_MAIN_FUNCTION_ARGUMENT;
if(yaml->AccessControlInfo.CanShareDeviceMemory) if(yaml->AccessControlInfo.CanShareDeviceMemory)
OtherCapabilities |= 1 << CAN_SHARE_DEVICE_MEMORY; OtherCapabilities |= 1 << othcap_CAN_SHARE_DEVICE_MEMORY;
if(yaml->AccessControlInfo.RunnableOnSleep) if(yaml->AccessControlInfo.RunnableOnSleep)
OtherCapabilities |= 1 << RUNNABLE_ON_SLEEP; OtherCapabilities |= 1 << othcap_RUNNABLE_ON_SLEEP;
if(yaml->AccessControlInfo.SpecialMemoryArrange) if(yaml->AccessControlInfo.SpecialMemoryArrange)
OtherCapabilities |= 1 << SPECIAL_MEMORY_ARRANGE; OtherCapabilities |= 1 << othcap_SPECIAL_MEMORY_ARRANGE;
if(yaml->AccessControlInfo.MemoryType){ if(yaml->AccessControlInfo.MemoryType){
u32 MemType = 0; u32 MemType = 0;
@@ -1042,7 +1049,7 @@ int SetARM11KernelDescOtherCapabilities(ARM11KernelCapabilityDescriptor *desc, r
fprintf(stderr,"[EXHEADER ERROR] Invalid memory type: '%s'\n",yaml->AccessControlInfo.MemoryType); fprintf(stderr,"[EXHEADER ERROR] Invalid memory type: '%s'\n",yaml->AccessControlInfo.MemoryType);
return EXHDR_BAD_YAML_OPT; return EXHDR_BAD_YAML_OPT;
} }
OtherCapabilities = (OtherCapabilities & -3841) | MemType << 8; OtherCapabilities = (OtherCapabilities & 0xffffff0f) | MemType << 8;
} }
if(OtherCapabilities){ if(OtherCapabilities){
@@ -1123,21 +1130,21 @@ int get_ExHeaderARM9AccessControlInfo(exhdr_ARM9AccessControlInfo *arm9, rsf_set
u32 Arm9AccessControl = 0; u32 Arm9AccessControl = 0;
for(int i = 0; i < yaml->AccessControlInfo.IoAccessControlNum; i++){ for(int i = 0; i < yaml->AccessControlInfo.IoAccessControlNum; i++){
if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"FsMountNand") == 0) 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) 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) 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) 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) 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) 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) 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) else if(strcmp(yaml->AccessControlInfo.IoAccessControl[i],"UseCardSpi") == 0)
Arm9AccessControl |= 1 << USE_CARD_SPI; Arm9AccessControl |= 1 << arm9cap_USE_CARD_SPI;
else{ else{
fprintf(stderr,"[EXHEADER ERROR] Invalid IoAccessControl Name: '%s'\n",yaml->AccessControlInfo.IoAccessControl[i]); fprintf(stderr,"[EXHEADER ERROR] Invalid IoAccessControl Name: '%s'\n",yaml->AccessControlInfo.IoAccessControl[i]);
return EXHDR_BAD_YAML_OPT; 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++){ for(int i = 0; i < yaml->AccessControlInfo.FileSystemAccessNum; i++){
if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0) if(strcmp(yaml->AccessControlInfo.FileSystemAccess[i],"DirectSdmc") == 0)
Arm9AccessControl |= 1 << USE_DIRECT_SDMC; Arm9AccessControl |= 1 << arm9cap_USE_DIRECT_SDMC;
} }
if(yaml->Option.UseOnSD) if(yaml->Option.UseOnSD)
Arm9AccessControl |= 1 << SD_APPLICATION; Arm9AccessControl |= 1 << arm9cap_SD_APPLICATION;
u32_to_u8(arm9->descriptors,Arm9AccessControl,LE); 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) int set_AccessDesc(exheader_settings *exhdrset, ncch_settings *ncchset)
{ {
switch(ncchset->Options.accessdesc){ if(ncchset->keys->AccessDescSign.PresetType == not_preset){
case auto_gen : if(ncchset->yaml_set->CommonHeaderKey.Found)
/* Set RSA Keys */ return accessdesc_GetSignFromRsf(exhdrset,ncchset);
memcpy(ncchset->CxiRsaKey.PrivK,exhdrset->keys->rsa.CFA_Priv,0x100); else if(!ncchset->keys->rsa.RequiresPresignedDesc)
memcpy(ncchset->CxiRsaKey.PubK,exhdrset->keys->rsa.CFA_Pub,0x100); return accessdesc_SignWithKey(exhdrset,ncchset);
memcpy(&exhdrset->ExHdr->AccessDescriptor.ncchpubkeymodulus,exhdrset->keys->rsa.CFA_Pub,0x100); else{
/* Copy Data From ExHeader */ fprintf(stderr,"[EXHEADER ERROR] Current keyset cannot sign AccessDesc, please appropriatly setup RSF, or specify a preset with -accessdesc\n");
memcpy(&exhdrset->ExHdr->AccessDescriptor.ARM11SystemLocalCapabilities,&exhdrset->ExHdr->ARM11SystemLocalCapabilities,sizeof(exhdr_ARM11SystemLocalCapabilities)); return CANNOT_SIGN_ACCESSDESC;
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
} }
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; return 0;
} }
exheader.h
+44 -44
View File
@@ -5,6 +5,7 @@ typedef enum
{ {
COMMON_HEADER_KEY_NOT_FOUND = -10, COMMON_HEADER_KEY_NOT_FOUND = -10,
EXHDR_BAD_YAML_OPT = -11, EXHDR_BAD_YAML_OPT = -11,
CANNOT_SIGN_ACCESSDESC = -12
} exheader_errors; } exheader_errors;
typedef enum typedef enum
@@ -37,60 +38,60 @@ typedef enum
typedef enum typedef enum
{ {
PERMIT_DEBUG, othcap_PERMIT_DEBUG,
FORCE_DEBUG, othcap_FORCE_DEBUG,
CAN_USE_NON_ALPHABET_AND_NUMBER, othcap_CAN_USE_NON_ALPHABET_AND_NUMBER,
CAN_WRITE_SHARED_PAGE, othcap_CAN_WRITE_SHARED_PAGE,
CAN_USE_PRIVILEGE_PRIORITY, othcap_CAN_USE_PRIVILEGE_PRIORITY,
PERMIT_MAIN_FUNCTION_ARGUMENT, othcap_PERMIT_MAIN_FUNCTION_ARGUMENT,
CAN_SHARE_DEVICE_MEMORY, othcap_CAN_SHARE_DEVICE_MEMORY,
RUNNABLE_ON_SLEEP, othcap_RUNNABLE_ON_SLEEP,
SPECIAL_MEMORY_ARRANGE = 12, othcap_SPECIAL_MEMORY_ARRANGE = 12,
} OtherCapabilities_Flagbitmask; } OtherCapabilities_Flagbitmask;
typedef enum typedef enum
{ {
CATEGORY_SYSTEM_APPLICATION, fsaccess_CATEGORY_SYSTEM_APPLICATION,
CATEGORY_HARDWARE_CHECK, fsaccess_CATEGORY_HARDWARE_CHECK,
CATEGORY_FILE_SYSTEM_TOOL, fsaccess_CATEGORY_FILE_SYSTEM_TOOL,
DEBUG, fsaccess_DEBUG,
TWL_CARD_BACKUP, fsaccess_TWL_CARD_BACKUP,
TWL_NAND_DATA, fsaccess_TWL_NAND_DATA,
BOSS, fsaccess_BOSS,
DIRECT_SDMC, fsaccess_DIRECT_SDMC,
CORE, fsaccess_CORE,
CTR_NAND_RO, fsaccess_CTR_NAND_RO,
CTR_NAND_RW, fsaccess_CTR_NAND_RW,
CTR_NAND_RO_WRITE, fsaccess_CTR_NAND_RO_WRITE,
CATEGORY_SYSTEM_SETTINGS, fsaccess_CATEGORY_SYSTEM_SETTINGS,
CARD_BOARD, fsaccess_CARD_BOARD,
EXPORT_IMPORT_IVS, fsaccess_EXPORT_IMPORT_IVS,
DIRECT_SDMC_WRITE, fsaccess_DIRECT_SDMC_WRITE,
SWITCH_CLEANUP, fsaccess_SWITCH_CLEANUP,
SAVE_DATA_MOVE, fsaccess_SAVE_DATA_MOVE,
SHOP, fsaccess_SHOP,
SHELL, fsaccess_SHELL,
CATEGORY_HOME_MENU fsaccess_CATEGORY_HOME_MENU
} FileSystemAccess; } FileSystemAccess;
typedef enum typedef enum
{ {
NOT_USE_ROMFS, attribute_NOT_USE_ROMFS,
USE_EXTENDED_SAVEDATA_ACCESS_CONTROL attribute_USE_EXTENDED_SAVEDATA_ACCESS_CONTROL
} AttributeName; } AttributeName;
typedef enum typedef enum
{ {
FS_MOUNT_NAND, arm9cap_FS_MOUNT_NAND,
FS_MOUNT_NAND_RO_WRITE, arm9cap_FS_MOUNT_NAND_RO_WRITE,
FS_MOUNT_TWLN, arm9cap_FS_MOUNT_TWLN,
FS_MOUNT_WNAND, arm9cap_FS_MOUNT_WNAND,
FS_MOUNT_CARD_SPI, arm9cap_FS_MOUNT_CARD_SPI,
USE_SDIF3, arm9cap_USE_SDIF3,
CREATE_SEED, arm9cap_CREATE_SEED,
USE_CARD_SPI, arm9cap_USE_CARD_SPI,
SD_APPLICATION, arm9cap_SD_APPLICATION,
USE_DIRECT_SDMC arm9cap_USE_DIRECT_SDMC
} Arm9Capability; } Arm9Capability;
typedef struct typedef struct
@@ -131,8 +132,6 @@ typedef struct
u8 ExtSaveDataId[8]; u8 ExtSaveDataId[8];
u8 SystemSaveDataId[8]; u8 SystemSaveDataId[8];
u8 StorageAccessableUniqueIds[8]; u8 StorageAccessableUniqueIds[8];
//u8 reserved[7];
//u8 flag;
u8 AccessInfo[7]; u8 AccessInfo[7];
u8 OtherAttributes; u8 OtherAttributes;
} exhdr_StorageInfo; } exhdr_StorageInfo;
@@ -203,6 +202,7 @@ typedef struct
{ {
keys_struct *keys; keys_struct *keys;
rsf_settings *yaml; rsf_settings *yaml;
bool UseAccessDescPreset;
/* Output */ /* Output */
ExtendedHeader_Struct *ExHdr; // is the exheader output buffer ptr(in ncchset) cast as exheader struct ptr; 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_ #ifndef _KEYS_DEBUG_H_
#define _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 static const unsigned char system_fixed_aesKey[16] = //system_fixed_aesKey
{ {
0x52, 0x7C, 0xE6, 0x30, 0xA9, 0xCA, 0x30, 0x5F, 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 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, 0xA1, 0x60, 0x4A, 0x6A, 0x71, 0x23, 0xB5, 0x29,
0xAE, 0x8B, 0xEC, 0x32, 0xC8, 0x16, 0xFC, 0xAA 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 //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, 0xD0, 0x1F, 0xE1, 0x00, 0xD4, 0x35, 0x56, 0xB2,
0x4B, 0x56, 0xDA, 0xE9, 0x71, 0xB5, 0xA5, 0xD3, 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 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 //Certificates
static const unsigned char ca4_dpki_cert[0x400] = static const unsigned char ca4_dpki_cert[0x400] =
{ {
keys_retail.h
+70 -74
View File
@@ -1,15 +1,46 @@
#ifndef _KEYS_RETAIL_H_ #ifndef _KEYS_RETAIL_H_
#define _KEYS_RETAIL_H_ #define _KEYS_RETAIL_H_
#ifndef PUBLIC_BUILD
// AES KEYS // 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, 0xD0, 0x7B, 0x33, 0x7F, 0x9C, 0xA4, 0x38, 0x59,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 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 // 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, 0xF8, 0x24, 0x6C, 0x58, 0xBA, 0xE7, 0x50, 0x03,
0x01, 0xFB, 0xB7, 0xC2, 0xEB, 0xE0, 0x01, 0x05, 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 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, 0xB1, 0xE3, 0xE3, 0x5F, 0x01, 0x39, 0x80, 0xD1,
0x56, 0x78, 0x9D, 0xB7, 0x06, 0xF7, 0x1D, 0xBF, 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 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, 0xDE, 0xCF, 0xB6, 0xFC, 0x3D, 0x33, 0xE9, 0x55,
0x0C, 0x01, 0xBD, 0x5C, 0x32, 0x2D, 0x90, 0xE0, 0xFD, 0xAC, 0x90, 0xE8, 0x88, 0x17, 0xB0, 0x03,
0xFF, 0x9A, 0x80, 0xE8, 0x66, 0x8D, 0x84, 0xDC, 0xA1, 0x6B, 0x9A, 0xAB, 0x72, 0x70, 0x79, 0x32,
0xF7, 0x75, 0x5F, 0x3F, 0x98, 0x7C, 0x97, 0x40, 0xA2, 0xA0, 0x8C, 0xBB, 0x33, 0x6F, 0xB0, 0x76,
0x20, 0x21, 0xB7, 0x24, 0xC0, 0x61, 0x2D, 0x83, 0x96, 0x2E, 0xC4, 0xE9, 0x2E, 0xD8, 0x8F, 0x92,
0xB0, 0x91, 0x8E, 0xE3, 0xC2, 0xD0, 0x2C, 0xA1, 0xC0, 0x2D, 0x4D, 0x41, 0x0F, 0xDE, 0x45, 0x1B,
0x2C, 0x99, 0x4F, 0x48, 0xF7, 0x4E, 0x13, 0xD3, 0x25, 0x3C, 0xBE, 0x37, 0x6B, 0x45, 0x82, 0x21,
0x01, 0x71, 0x25, 0x9B, 0x3C, 0x75, 0x7C, 0xC4, 0xE6, 0x4D, 0xB1, 0x23, 0x81, 0x82, 0xB6, 0x81,
0xE5, 0x89, 0x7E, 0xDA, 0xF9, 0x99, 0x5C, 0x83, 0x62, 0xB7, 0x30, 0xF4, 0x60, 0x4B, 0xC7, 0xF7,
0xE4, 0xDD, 0x36, 0x62, 0x5B, 0x0E, 0x12, 0x91, 0xF0, 0x17, 0x0C, 0xB5, 0x75, 0x88, 0x77, 0x93,
0xD6, 0x39, 0x45, 0x69, 0x62, 0x20, 0xCA, 0xF4, 0x52, 0x63, 0x70, 0xF0, 0x0B, 0xC6, 0x73, 0x43,
0xBA, 0x6B, 0x28, 0x1A, 0x7C, 0xBF, 0xB9, 0x97, 0x41, 0xEE, 0xE4, 0xF0, 0x71, 0xEC, 0xC8, 0xC1,
0x37, 0x46, 0xC2, 0x7A, 0xCF, 0x10, 0x68, 0xC2, 0x32, 0xC4, 0xDC, 0xA9, 0x99, 0x1D, 0x31, 0xB8,
0xC9, 0xF1, 0x48, 0xDA, 0x8A, 0x2F, 0x4C, 0xBC, 0xA4, 0x7E, 0xDD, 0x19, 0x04, 0x0F, 0x02, 0xA8,
0x3B, 0x1C, 0xB8, 0x8F, 0x04, 0x7F, 0xFD, 0x9D, 0x1A, 0xAF, 0xB3, 0x48, 0x9A, 0x29, 0x29, 0x5E,
0xE2, 0x0A, 0xD2, 0x09, 0x39, 0xC7, 0xD9, 0x81, 0x49, 0x84, 0xE0, 0x94, 0x11, 0xD1, 0x7E, 0xAB,
0x59, 0x17, 0x73, 0xB2, 0xEC, 0xEB, 0x36, 0x67, 0xB2, 0xC0, 0x44, 0x7E, 0xA1, 0x1B, 0x5E, 0x9D,
0xA5, 0xA8, 0xD5, 0x71, 0xD9, 0x38, 0x6A, 0xD1, 0x0D, 0x1A, 0xF9, 0x02, 0x9A, 0x2E, 0x53, 0x03,
0x28, 0xB9, 0x46, 0x85, 0x3A, 0x81, 0x85, 0x4E, 0x2D, 0x48, 0x96, 0x7C, 0x2C, 0xA6, 0xD7, 0xAC,
0x55, 0xA7, 0x74, 0x79, 0xBB, 0xC5, 0x97, 0xF7, 0xF1, 0xED, 0x2B, 0x18, 0xBB, 0x01, 0xCB, 0x13,
0xEF, 0xE0, 0x81, 0x20, 0xE0, 0xEA, 0x45, 0x8F, 0xB9, 0xAC, 0xA6, 0xEE, 0x55, 0x00, 0x37, 0x7C,
0xED, 0x70, 0x8E, 0xD6, 0xFF, 0x49, 0xCF, 0x7F, 0x69, 0x61, 0x62, 0x89, 0x01, 0x54, 0x77, 0x9F,
0xF2, 0xFF, 0x22, 0x20, 0x3F, 0xE9, 0x92, 0x99, 0x07, 0x5D, 0x26, 0x34, 0x3A, 0xA9, 0x49, 0xA5,
0xDE, 0x81, 0xD6, 0x27, 0xF7, 0xB8, 0x3A, 0x1D, 0xAF, 0xF2, 0x5E, 0x06, 0x51, 0xB7, 0x1C, 0xE0,
0x4F, 0xA2, 0x50, 0xFB, 0xA5, 0xE7, 0x98, 0x08, 0xDE, 0xDA, 0x5C, 0x0B, 0x9F, 0x98, 0xC2, 0x15,
0xB5, 0x2B, 0xA2, 0x94, 0xA9, 0x17, 0x1A, 0xA8, 0xFD, 0xBA, 0xD8, 0xA9, 0x99, 0x00, 0xAB, 0xA4,
0x34, 0xF6, 0x5E, 0x24, 0x2D, 0x40, 0x2F, 0xCB, 0x8E, 0x4A, 0x16, 0x9D, 0x66, 0x2A, 0xE8, 0x56,
0x3C, 0xB0, 0xF8, 0x7E, 0x84, 0xB4, 0x87, 0x82, 0x64, 0xB2, 0xB6, 0xC0, 0x93, 0xAF, 0x4D, 0x38,
0x19, 0xAF, 0x87, 0xB6, 0xFA, 0xA9, 0x67, 0x27, 0xA0, 0x16, 0x5C, 0xE4, 0xBD, 0x62, 0xC2, 0x46,
0x07, 0x28, 0xBA, 0x2E, 0xA5, 0x8E, 0xDD, 0xE5, 0x6B, 0xC9, 0x5A, 0x59, 0x4A, 0x72, 0x58, 0xFD,
0xD4, 0xFD, 0x06, 0x09, 0xDF, 0xBD, 0x87, 0x95, 0xB2, 0xCC, 0x36, 0x87, 0x30, 0x85, 0xE8, 0xA1,
0x95, 0x25, 0x05, 0x5E, 0xB2, 0x00, 0x18, 0x41 0x04, 0x5B, 0xE0, 0x17, 0x9B, 0xD0, 0xEC, 0x9B
};
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
//Certificates //Certificates
static const unsigned char ca3_dpki_cert[0x400] = static const unsigned char ca3_dpki_cert[0x400] =
keyset.c
+80 -49
View File
@@ -1,8 +1,16 @@
#include "lib.h" #include "lib.h"
// KeyData
#include "keys_common.h"
#include "keys_retail.h"
#ifndef PUBLIC_BUILD
#include "keys_debug.h"
#endif
// Private Prototypes // Private Prototypes
int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource); int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource);
int SetUnFixedKey(keys_struct *keys, u8 *UnFixedKey); int SetUnFixedKey(keys_struct *keys, u8 *UnFixedKey);
void InitCommonKeySlots(keys_struct *keys);
int SetTIK_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod); int SetTIK_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetTMD_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) void InitKeys(keys_struct *keys)
{ {
memset(keys,0,sizeof(keys_struct)); memset(keys,0,sizeof(keys_struct));
InitCommonKeySlots(keys);
#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);
/* RSA Keys */ void SetKeys(keys_struct *keys)
// CIA {
SetTIK_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod); if(keys->keyset == keyset_RETAIL){
SetTMD_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod); /* AES Keys */
// CFA // CIA
SetCFA_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod); //SetCommonKey(keys,(u8*)zeros_fixed_aesKey,1);
// CCI SetCurrentCommonKey(keys,1);
SetCCI_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
/* Certs */ // NCCH
SetCaCert(keys,(u8*)ca3_dpki_cert); keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetTikCert(keys,(u8*)xsC_dpki_cert); SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
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);
/* RSA Keys */ /* RSA Keys */
// CIA keys->rsa.FalseSign = true;
SetTIK_RsaKey(keys,(u8*)xs9_dpki_rsa_privExp,(u8*)xs9_dpki_rsa_pubMod); // CIA
SetTMD_RsaKey(keys,(u8*)cpA_dpki_rsa_privExp,(u8*)cpA_dpki_rsa_pubMod); SetTIK_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CFA SetTMD_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetCFA_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod); // CFA
// CCI SetCFA_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetCCI_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod); // CCI
// CXI SetCCI_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetAccessDesc_RsaKey(keys,(u8*)AccessDesc_privExp,(u8*)AccessDesc_pubMod); // CXI
SetAccessDesc_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
/* Certs */ /* Certs */
SetCaCert(keys,(u8*)ca4_dpki_cert); SetCaCert(keys,(u8*)ca3_dpki_cert);
SetTikCert(keys,(u8*)xs9_dpki_cert); SetTikCert(keys,(u8*)xsC_dpki_cert);
SetTmdCert(keys,(u8*)cpA_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 #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) 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) int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index)
{ {
if(!keys) return -1; if(!keys) return -1;
return CopyData(&keys->aes.CommonKey[Index],CommonKey,16);
}
void InitCommonKeySlots(keys_struct *keys)
{
if(!keys->aes.CommonKey){ if(!keys->aes.CommonKey){
keys->aes.CommonKey = malloc(sizeof(u8*)*256); keys->aes.CommonKey = malloc(sizeof(u8*)*256);
memset(keys->aes.CommonKey,0,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) int SetCurrentCommonKey(keys_struct *keys, u8 Index)
keyset.h
+25
View File
@@ -1,10 +1,32 @@
#ifndef _KEYSET_H_ #ifndef _KEYSET_H_
#define _KEYSET_H_ #define _KEYSET_H_
typedef enum
{
keyset_DEBUG,
keyset_RETAIL,
} keysets;
typedef enum
{
not_preset,
app,
dlp,
demo,
} fixed_accessdesc_type;
// Structs // Structs
typedef struct typedef struct
{ {
keysets keyset;
struct
{
fixed_accessdesc_type PresetType;
u32 TargetFirmware;
} AccessDescSign;
struct struct
{ {
// CIA // CIA
@@ -19,6 +41,7 @@ typedef struct
struct struct
{ {
bool FalseSign;
// CIA RSA // CIA RSA
u8 *TMD_Priv; u8 *TMD_Priv;
u8 *TMD_Pub; u8 *TMD_Pub;
@@ -34,6 +57,7 @@ typedef struct
u8 *CCI_Pub; u8 *CCI_Pub;
// CXI // CXI
bool RequiresPresignedDesc;
u8 *AccessDesc_Priv; u8 *AccessDesc_Priv;
u8 *AccessDesc_Pub; u8 *AccessDesc_Pub;
} rsa; } rsa;
@@ -51,6 +75,7 @@ typedef struct
// Public Prototypes // Public Prototypes
void InitKeys(keys_struct *keys); void InitKeys(keys_struct *keys);
void SetKeys(keys_struct *keys);
void FreeKeys(keys_struct *keys); void FreeKeys(keys_struct *keys);
int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index); int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index);
lib.h
+1 -6
View File
@@ -26,12 +26,7 @@
#include "types.h" #include "types.h"
#include "utils.h" #include "utils.h"
#include "crypto.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 "keyset.h"
#include "usersettings.h" #include "usersettings.h"
#include "libyaml/yaml.h" #include "libyaml/yaml.h"
makerom.c
+45 -12
View File
@@ -12,19 +12,30 @@ int main(int argc, char *argv[])
int result; int result;
#ifdef DEBUG
printf("[DEBUG] Parseing Args\n");
#endif
// Parsing command args // Parsing command args
result = ParseArgs(argc,argv,usrset); 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 // Import RSF Settings if present
result = GetYamlSettings(usrset); result = GetYamlSettings(usrset);
if(result < 0) goto fail_finalise; if(result < 0) goto finish;
// Setup Content 0 // Setup Content 0
if(!usrset->IsBuildingNCCH0){ // Import Content 0 if(!usrset->IsBuildingNCCH0){ // Import Content 0
if(usrset->Content0IsNcch){ if(usrset->Content0IsNcch){
#ifdef DEBUG
printf("[DEBUG] Import NCCH0\n");
#endif
FILE *ncch0 = fopen(usrset->ContentPath[0],"rb"); 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); fclose(ncch0);
usrset->Content0.size = GetFileSize_u64(usrset->ContentPath[0]); usrset->Content0.size = GetFileSize_u64(usrset->ContentPath[0]);
usrset->Content0.buffer = malloc(usrset->Content0.size); usrset->Content0.buffer = malloc(usrset->Content0.size);
@@ -33,8 +44,11 @@ int main(int argc, char *argv[])
fclose(ncch0); fclose(ncch0);
} }
else if(usrset->Content0IsSrl){ else if(usrset->Content0IsSrl){
#ifdef DEBUG
printf("[DEBUG] Import SRL\n");
#endif
FILE *srl = fopen(usrset->SrlPath,"rb"); 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); fclose(srl);
u64 size = GetFileSize_u64(usrset->SrlPath); u64 size = GetFileSize_u64(usrset->SrlPath);
usrset->Content0.size = align_value(size,0x10); usrset->Content0.size = align_value(size,0x10);
@@ -44,8 +58,11 @@ int main(int argc, char *argv[])
fclose(srl); fclose(srl);
} }
else if(usrset->ConvertCci){ else if(usrset->ConvertCci){
#ifdef DEBUG
printf("[DEBUG] Import CCI\n");
#endif
FILE *cci = fopen(usrset->CciPath,"rb"); 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); fclose(cci);
usrset->Content0.size = GetFileSize_u64(usrset->CciPath); usrset->Content0.size = GetFileSize_u64(usrset->CciPath);
usrset->Content0.buffer = malloc(usrset->Content0.size); usrset->Content0.buffer = malloc(usrset->Content0.size);
@@ -55,39 +72,55 @@ int main(int argc, char *argv[])
} }
} }
else{// Build Content 0 else{// Build Content 0
#ifdef DEBUG
printf("[DEBUG] Build NCCH0\n");
#endif
result = build_NCCH(usrset); result = build_NCCH(usrset);
if(result < 0) { if(result < 0) {
//fprintf(stderr,"[ERROR] %s generation failed\n",usrset->build_ncch_type == CXI? "CXI" : "CFA"); //fprintf(stderr,"[ERROR] %s generation failed\n",usrset->build_ncch_type == CXI? "CXI" : "CFA");
fprintf(stderr,"[RESULT] Failed to build outfile\n"); fprintf(stderr,"[RESULT] Failed to build outfile\n");
goto fail_finalise; goto finish;
} }
} }
// Make CCI // Make CCI
if(usrset->out_format == CCI){ if(usrset->out_format == CCI){
#ifdef DEBUG
printf("[DEBUG] Building CCI\n");
#endif
result = build_CCI(usrset); 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 // Make CIA
else if(usrset->out_format == CIA){ else if(usrset->out_format == CIA){
#ifdef DEBUG
printf("[DEBUG] Building CIA\n");
#endif
result = build_CIA(usrset); 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 // No Container Raw CXI/CFA
else if(usrset->out_format == CXI || usrset->out_format == 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"); FILE *ncch_out = fopen(usrset->outfile,"wb");
if(!ncch_out) { if(!ncch_out) {
fprintf(stderr,"[ERROR] Failed to create '%s'\n",usrset->outfile); fprintf(stderr,"[ERROR] Failed to create '%s'\n",usrset->outfile);
fprintf(stderr,"[RESULT] Failed to build '%s'\n",usrset->out_format == CXI? "CXI" : "CFA"); fprintf(stderr,"[RESULT] Failed to build '%s'\n",usrset->out_format == CXI? "CXI" : "CFA");
result = FAILED_TO_CREATE_OUTFILE; result = FAILED_TO_CREATE_OUTFILE;
goto fail_finalise; goto finish;
} }
WriteBuffer(usrset->Content0.buffer,usrset->Content0.size,0,ncch_out); WriteBuffer(usrset->Content0.buffer,usrset->Content0.size,0,ncch_out);
fclose(ncch_out); fclose(ncch_out);
} }
finish:
#ifdef DEBUG
printf("[DEBUG] Free Context\n");
#endif
free_UserSettings(usrset); free_UserSettings(usrset);
return 0; #ifdef DEBUG
fail_finalise: printf("[DEBUG] Finished returning (result=%d)\n",result);
free_UserSettings(usrset); #endif
return result; return result;
} }
ncch.c
+51 -27
View File
@@ -5,7 +5,8 @@
#include "exefs.h" #include "exefs.h"
#include "romfs.h" #include "romfs.h"
#include "titleid.h" #include "titleid.h"
#include "logo_data.h"
#include "logo_data.h" // Contains Logos
// Private Prototypes // Private Prototypes
int SignCFA(u8 *Signature, u8 *CFA_HDR, keys_struct *keys); 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 build_NCCH(user_settings *usrset)
{ {
int result; int result;
#ifdef DEBUG
printf("[DEBUG] Init Settings\n");
#endif
// Init Settings // Init Settings
ncch_settings *ncchset = malloc(sizeof(ncch_settings)); ncch_settings *ncchset = malloc(sizeof(ncch_settings));
if(!ncchset) {fprintf(stderr,"[NCCH ERROR] MEM ERROR\n"); return MEM_ERROR;} if(!ncchset) {fprintf(stderr,"[NCCH ERROR] MEM ERROR\n"); return MEM_ERROR;}
init_NCCHSettings(ncchset); init_NCCHSettings(ncchset);
#ifdef DEBUG
printf("[DEBUG] Get Settings\n");
#endif
// Get Settings // Get Settings
result = get_NCCHSettings(ncchset,usrset); result = get_NCCHSettings(ncchset,usrset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Build ExeFS Code/PlainRegion\n");
#endif
// Build ExeFs Code Section // Build ExeFs Code Section
result = BuildExeFsCode(ncchset); result = BuildExeFsCode(ncchset);
if(result) goto finish; if(result) goto finish;
@@ -82,25 +90,46 @@ int build_NCCH(user_settings *usrset)
memdump(stdout,"Code Hash: ",hash,0x20); memdump(stdout,"Code Hash: ",hash,0x20);
#endif #endif
#ifdef DEBUG
printf("[DEBUG] Build Exheader\n");
#endif
// Build ExHeader // Build ExHeader
result = BuildExHeader(ncchset); result = BuildExHeader(ncchset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Exefs\n");
#endif
// Build ExeFs/RomFs // Build ExeFs/RomFs
result = BuildExeFs(ncchset); result = BuildExeFs(ncchset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Build Romfs\n");
#endif
result = BuildRomFs(ncchset); result = BuildRomFs(ncchset);
if(result) goto finish; if(result) goto finish;
// Final Steps // Final Steps
#ifdef DEBUG
printf("[DEBUG] Build common header\n");
#endif
result = BuildCommonHeader(ncchset); result = BuildCommonHeader(ncchset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Encrypt Sections\n");
#endif
result = EncryptNCCHSections(ncchset); result = EncryptNCCHSections(ncchset);
if(result) goto finish; if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Write Sections\n");
#endif
result = WriteNCCHSectionsToBuffer(ncchset); result = WriteNCCHSectionsToBuffer(ncchset);
if(result) goto finish; if(result) goto finish;
finish: finish:
#ifdef DEBUG
printf("[DEBUG] Finish Building\n");
#endif
if(result) fprintf(stderr,"[NCCH ERROR] NCCH Build Process Failed\n"); if(result) fprintf(stderr,"[NCCH ERROR] NCCH Build Process Failed\n");
free_NCCHSettings(ncchset); free_NCCHSettings(ncchset);
return result; return result;
@@ -194,8 +223,6 @@ int SetBasicOptions(ncch_settings *ncchset, user_settings *usrset)
return NCCH_BAD_YAML_SET; return NCCH_BAD_YAML_SET;
} }
ncchset->Options.accessdesc = usrset->accessdesc;
ncchset->CxiRsaKey.PrivK = malloc(0x100); ncchset->CxiRsaKey.PrivK = malloc(0x100);
ncchset->CxiRsaKey.PubK = 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) 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){ if(usrset->elf_path){
ncchset->ComponentFilePtrs.elf_size = GetFileSize_u64(usrset->elf_path); ncchset->ComponentFilePtrs.elf_size = GetFileSize_u64(usrset->elf_path);
ncchset->ComponentFilePtrs.elf = fopen(usrset->elf_path,"rb"); 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; 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){ if(usrset->plain_region_path){
ncchset->ComponentFilePtrs.plainregion_size = GetFileSize_u64(usrset->plain_region_path); ncchset->ComponentFilePtrs.plainregion_size = GetFileSize_u64(usrset->plain_region_path);
ncchset->ComponentFilePtrs.plainregion = fopen(usrset->plain_region_path,"rb"); 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) int ImportNonCodeExeFsSections(ncch_settings *ncchset)
{ {
if(ncchset->Options.IsCfa) return 0;
if(ncchset->ComponentFilePtrs.banner){ if(ncchset->ComponentFilePtrs.banner){
ncchset->ExeFs_Sections.Banner.size = ncchset->ComponentFilePtrs.banner_size; ncchset->ExeFs_Sections.Banner.size = ncchset->ComponentFilePtrs.banner_size;
ncchset->ExeFs_Sections.Banner.buffer = malloc(ncchset->ExeFs_Sections.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) int ImportLogo(ncch_settings *ncchset)
{ {
if(ncchset->Options.IsCfa) return 0;
if(ncchset->ComponentFilePtrs.logo){ if(ncchset->ComponentFilePtrs.logo){
ncchset->Sections.Logo.size = ncchset->ComponentFilePtrs.logo_size; ncchset->Sections.Logo.size = ncchset->ComponentFilePtrs.logo_size;
ncchset->Sections.Logo.buffer = malloc(ncchset->Sections.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); GetCXIStruct(ncch_ctx,hdr);
if(IsCfa(hdr)){ if(IsCfa(hdr)){
if(CheckCFASignature(hdr_sig,(u8*)hdr,keys) != Good){ if(CheckCFASignature(hdr_sig,(u8*)hdr,keys) != Good && !keys->rsa.FalseSign){
#ifdef RETAIL_FSIGN
if(!SuppressOutput) fprintf(stderr,"[NCCH WARNING] CFA Sigcheck Failed\n");
#else
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CFA Sigcheck Failed\n"); if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CFA Sigcheck Failed\n");
free(ncch_ctx); free(ncch_ctx);
return NCCH_HDR_SIG_BAD; return NCCH_HDR_SIG_BAD;
#endif
} }
if(!ncch_ctx->romfs_size){ if(!ncch_ctx->romfs_size){
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CFA is corrupt\n"); 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 // Checking RSA Sigs
u8 *hdr_pubk = GetNcchHdrPubKey_frm_exhdr(ExHeader); u8 *hdr_pubk = GetNcchHdrPubKey_frm_exhdr(ExHeader);
if(CheckAccessDescSignature(ExHeader,keys) != 0){ if(CheckAccessDescSignature(ExHeader,keys) != 0 && !keys->rsa.FalseSign){
#ifdef RETAIL_FSIGN
if(!SuppressOutput) fprintf(stderr,"[NCCH WARNING] AccessDesc Sigcheck Failed\n");
#else
if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] AccessDesc Sigcheck Failed\n"); if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] AccessDesc Sigcheck Failed\n");
free(ncch_ctx); free(ncch_ctx);
free(ExHeader); free(ExHeader);
return ACCESSDESC_SIG_BAD; 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"); if(!SuppressOutput) fprintf(stderr,"[NCCH ERROR] CXI Header Sigcheck Failed\n");
free(ncch_ctx); free(ncch_ctx);
free(ExHeader); free(ExHeader);
@@ -780,8 +802,8 @@ u8* RetargetNCCH(FILE *fp, u64 size, u8 *TitleId, u8 *ProgramId, keys_struct *ke
NCCH_Header *hdr = NULL; NCCH_Header *hdr = NULL;
hdr = GetNCCH_CommonHDR(NULL,NULL,ncch); hdr = GetNCCH_CommonHDR(NULL,NULL,ncch);
if(!IsCfa(hdr)){ if(/*keys->rsa.RequiresPresignedDesc && */!IsCfa(hdr)){
fprintf(stderr,"[NCCH ERROR] CXI's ID cannot be modified\n"); // Not yet yet, requires AccessDesc Privk, may implement anyway later 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); free(ncch);
return NULL; return NULL;
} }
@@ -1060,4 +1082,6 @@ void ncch_get_counter(NCCH_STRUCT *ctx, u8 counter[16], u8 type)
for(i=0; i<4; i++) for(i=0; i<4; i++)
counter[12+i] = x>>((3-i)*8); counter[12+i] = x>>((3-i)*8);
} }
//memdump(stdout,"CTR: ",counter,16);
} }
ncch.h
-3
View File
@@ -135,9 +135,6 @@ typedef struct
struct struct
{ {
u32 MediaSize; u32 MediaSize;
fixed_accessdesc_type accessdesc;
bool IncludeExeFsLogo; bool IncludeExeFsLogo;
bool CompressCode; bool CompressCode;
bool UseOnSD; bool UseOnSD;
ncsd.c
+3
View File
@@ -413,6 +413,8 @@ int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml)
} }
/* Platform */ /* Platform */
cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
/*
if(!yaml->TitleInfo.Platform) cciset->NCSD_Flags[MediaPlatformIndex] = CTR; if(!yaml->TitleInfo.Platform) cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
else{ else{
if(strcasecmp(yaml->TitleInfo.Platform,"ctr") == 0) cciset->NCSD_Flags[MediaPlatformIndex] = CTR; 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; return INVALID_YAML_OPT;
} }
} }
*/
/* CardDevice */ /* CardDevice */
if(!yaml->CardInfo.CardDevice) cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NONE; 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 SetupTicketBuffer(COMPONENT_STRUCT *tik);
int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset); int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset);
int SignTicketHeader(TicketStruct *hdr, TicketSignatureStruct *sig, keys_struct *keys); int SignTicketHeader(TicketStruct *hdr, TicketSignatureStruct *sig, keys_struct *keys);
void SetUnknownTicketData(u8 *dest, u8 type); void SetContentIndexData(u8 *dest);
int BuildTicket(cia_settings *ciaset) int BuildTicket(cia_settings *ciaset)
@@ -42,13 +42,14 @@ int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset)
hdr->TicketFormatVersion = ciaset->tik.ticket_format_ver; hdr->TicketFormatVersion = ciaset->tik.ticket_format_ver;
hdr->ca_crl_version = ciaset->cert.ca_crl_version; hdr->ca_crl_version = ciaset->cert.ca_crl_version;
hdr->signer_crl_version = ciaset->cert.signer_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->TicketID,ciaset->tik.TicketID,8);
memcpy(hdr->DeviceID,ciaset->tik.DeviceID,8); memcpy(hdr->DeviceID,ciaset->tik.DeviceID,8);
memcpy(hdr->TitleID,ciaset->TitleID,8); memcpy(hdr->TitleID,ciaset->TitleID,8);
memcpy(hdr->TicketVersion,ciaset->tik.TicketVersion,2); memcpy(hdr->TicketVersion,ciaset->tik.TicketVersion,2);
hdr->CommonKeyID = ciaset->keys->aes.CurrentCommonKey; hdr->CommonKeyID = ciaset->keys->aes.CurrentCommonKey;
SetUnknownTicketData(hdr->StaticData,ciaset->tik.UnknownDataType); SetContentIndexData(hdr->StaticData);
return 0; return 0;
} }
@@ -79,11 +80,7 @@ int CryptTitleKey(u8 *EncTitleKey, u8 *DecTitleKey, u8 *TitleID, keys_struct *ke
return 0; return 0;
} }
void SetUnknownTicketData(u8 *dest, u8 type) void SetContentIndexData(u8 *dest)
{ {
switch(type){ memcpy(dest,normal_static_ticket_data,0x30);
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;
}
} }
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 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
}; };
/*
static const unsigned char system_static_ticket_data[0x30] = static const unsigned char system_static_ticket_data[0x30] =
{ {
0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAC, 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, 0x84, 0x00, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
}; };
*/
typedef enum typedef enum
{ {
lic_Permanent = 0, lic_Permanent = 0,
@@ -41,13 +42,6 @@ typedef enum
right_AccessTitle = 5 right_AccessTitle = 5
} ticket_item_rights; } ticket_item_rights;
typedef enum
{
tik_normal = 1,
tik_system,
tik_test
} cia_type;
typedef struct typedef struct
{ {
u8 sig_type[4]; 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*)); memset(usr_settings->ContentPath,0,CIA_MAX_CONTENT*sizeof(char*));
// Initialise Keys
InitKeys(&usr_settings->keys);
// Setting Defaults // Setting Defaults
SetDefaults(usr_settings); SetDefaults(usr_settings);
// Initialise Keys // Parsing Arguments
InitKeys(&usr_settings->keys);
// Reading Arguments
int set_result; int set_result;
int i = 1; int i = 1;
while(i < argc){ while(i < argc){
@@ -54,9 +54,13 @@ int ParseArgs(int argc, char *argv[], user_settings *usr_settings)
i += set_result; i += set_result;
} }
// Checking arguments
set_result = CheckArgumentCombination(usr_settings); set_result = CheckArgumentCombination(usr_settings);
if(set_result) return set_result; if(set_result) return set_result;
// Setting Keys
SetKeys(&usr_settings->keys);
if(!usr_settings->outfile){ if(!usr_settings->outfile){
char *source_path = NULL; char *source_path = NULL;
if(usr_settings->IsBuildingNCCH0) source_path = usr_settings->rsf_path; 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) void SetDefaults(user_settings *set)
{ {
// Target Info
set->keys.keyset = keyset_RETAIL;
// Build NCCH Info // Build NCCH Info
set->IsBuildingNCCH0 = true; set->IsBuildingNCCH0 = true;
#ifdef RETAIL_FSIGN
set->accessdesc = auto_gen;
#else
set->accessdesc = use_spec_file;
#endif
set->include_exefs_logo = false; set->include_exefs_logo = false;
set->out_format = CXI; set->out_format = CXI;
set->build_ncch_type = format_not_set; 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 // Content0 Info
set->Content0IsNcch = true; set->Content0IsNcch = true;
set->ConvertCci = false; set->ConvertCci = false;
@@ -100,7 +108,7 @@ void SetDefaults(user_settings *set)
set->OmitImportedNcchHdr = false; set->OmitImportedNcchHdr = false;
// CIA Info // CIA Info
set->EncryptContents = false; set->EncryptContents = true;
set->RandomTitleKey = false; set->RandomTitleKey = false;
for(int i = 0; i < CIA_MAX_CONTENT; i++){ for(int i = 0; i < CIA_MAX_CONTENT; i++){
set->ContentID[i] = 0x100000000; set->ContentID[i] = 0x100000000;
@@ -114,7 +122,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
if(!IsLastArg){ if(!IsLastArg){
if(argv[i+1][0] != '-') HasParam = true; if(argv[i+1][0] != '-') HasParam = true;
} }
if(strcmp(argv[i],"-elf") == 0){ if(strcmp(argv[i],"-elf") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-elf"); PrintNeedsParam("-elf");
@@ -164,7 +171,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->outfile_mallocd = false; set->outfile_mallocd = false;
return 2; return 2;
} }
#ifdef PRIVATE_BUILD
else if(strcmp(argv[i],"-exheader") == 0){ else if(strcmp(argv[i],"-exheader") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-exheader"); PrintNeedsParam("-exheader");
@@ -197,6 +203,21 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->plain_region_path = argv[i+1]; set->plain_region_path = argv[i+1];
return 2; 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){ else if(strcmp(argv[i],"-cci") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-cci"); PrintNeedsParam("-cci");
@@ -240,7 +261,15 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->OmitImportedNcchHdr = true; set->OmitImportedNcchHdr = true;
return 1; 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){ else if(strcmp(argv[i],"-f") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-f"); PrintNeedsParam("-f");
@@ -256,20 +285,6 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
} }
return 2; 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){ else if(strcmp(argv[i],"-sysfixedkey") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-sysfixedkey"); PrintNeedsParam("-sysfixedkey");
@@ -315,24 +330,38 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
free(key); free(key);
return 2; return 2;
} }
#endif
else if(strcmp(argv[i],"-accessdesc") == 0){ else if(strcmp(argv[i],"-accessdesc") == 0){
if(!HasParam){ if(!HasParam){
PrintNeedsParam("-accessdesc"); PrintNeedsParam("-accessdesc");
return USR_ARG_REQ_PARAM; return USR_ARG_REQ_PARAM;
} }
char *tmp = argv[i+1];
if(strcasecmp(argv[i+1],"UseRsf") == 0) set->accessdesc = use_spec_file; char *tmp2 = strstr(tmp,":");
else if(strcasecmp(argv[i+1],"AutoGen") == 0 || strcasecmp(argv[i+1],"Auto") == 0) set->accessdesc = auto_gen; if(!tmp2){
#ifndef RETAIL_FSIGN fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
else if(strcasecmp(argv[i+1],"App") == 0) set->accessdesc = app; fprintf(stderr," -accessdesc <APP TYPE>:<TARGET FIRMWARE>\n");
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; if(strlen(tmp2) < 2){
#endif 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{ 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; return USR_BAD_ARG;
} }
char *target_firmware = (tmp2+1);
set->keys.AccessDescSign.TargetFirmware = strtoul(target_firmware,NULL,10);
return 2; return 2;
} }
@@ -352,12 +381,12 @@ int SetArgument(int argc, int i, char *argv[], user_settings *set)
set->RandomTitleKey = true; set->RandomTitleKey = true;
return 1; return 1;
} }
else if(strcmp(argv[i],"-encryptcia") == 0){ else if(strcmp(argv[i],"-nocryptcia") == 0){
if(HasParam){ if(HasParam){
PrintNoNeedParam("-encryptcia"); PrintNoNeedParam("-nocryptcia");
return USR_BAD_ARG; return USR_BAD_ARG;
} }
set->EncryptContents = true; set->EncryptContents = false;
return 1; return 1;
} }
else if(strcmp(argv[i],"-major") == 0){ else if(strcmp(argv[i],"-major") == 0){
@@ -525,31 +554,6 @@ int CheckArgumentCombination(user_settings *set)
return 0; 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) void init_UserSettings(user_settings *usr_settings)
{ {
memset(usr_settings,0,sizeof(user_settings)); memset(usr_settings,0,sizeof(user_settings));
@@ -791,43 +795,46 @@ void PrintNoNeedParam(char *arg)
void DisplayHelp(char *app_name) void DisplayHelp(char *app_name)
{ {
printf("CTR MAKEROM %d.%d",MAKEROM_VER_MAJOR,MAKEROM_VER_MINOR); printf("CTR MAKEROM %d.%d",MAKEROM_VER_MAJOR,MAKEROM_VER_MINOR);
#ifdef PRIVATE_BUILD #ifndef PUBLIC_BUILD
printf(" PRIVATE BUILD"); printf(" PRIVATE BUILD");
#endif #endif
printf("\n(C) 3DSGuy 2014\n"); printf("\n(C) 3DSGuy 2014\n");
printf("Usage: %s [options... ]\n",app_name); printf("Usage: %s [options... ]\n",app_name);
printf("Option Parameter Explanation\n"); printf("Option Parameter Explanation\n");
printf("Global Options:\n"); printf("GLOBAL OPTIONS:\n");
printf(" -help Display this text\n"); printf(" -help Display this text\n");
printf(" -rsf <rsf path> RSF File\n"); printf(" -rsf <rsf path> RSF File\n");
printf(" -f <out format> Output Format (cxi|cfa|cci|cia)\n"); printf(" -f <out format> Output Format (cxi|cfa|cci|cia)\n");
printf(" -o <outfile> Output File\n"); printf(" -o <outfile> Output File\n");
//printf(" -v Verbose\n");
//printf(" -DNAME=VALUE Substitute values in Spec files\n"); //printf(" -DNAME=VALUE Substitute values in Spec files\n");
printf("NCCH Options:\n"); printf("KEY OPTIONS:\n");
printf(" -ncch0 <ncch format> NCCH Format (cxi|cfa)\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(" -elf <elf path> ELF File\n");
printf(" -icon <icon path> Icon File\n"); printf(" -icon <icon path> Icon File\n");
printf(" -banner <banner path> Banner File\n"); printf(" -banner <banner path> Banner File\n");
printf(" -logo <logo path> Logo File\n"); printf(" -logo <logo path> Logo File (Overrides \"BasicInfo/Logo\" in RSF)\n");
printf(" -exefslogo Include Logo in ExeFs\n"); printf(" -accessdesc <apptype>:<fw> Specify AccessDesc Preset\n");
printf(" -accessdesc <accessdesc type> (AutoGen|UseRsf)\n"); printf(" -exefslogo Include Logo in ExeFs (Required for usage on <5.X Systems)\n");
#ifdef RETAIL_FSIGN printf(" -cfa Specify if building a Data Archive when \"-f cia\"\n");
printf(" -sysfixedkey <32 hex chars> Specify SystemFixed Key\n"); printf("NCCH REBUILD OPTIONS:\n");
#endif
#ifdef PRIVATE_BUILD
printf(" -code <code path> Specify ExeFs code File\n"); printf(" -code <code path> Specify ExeFs code File\n");
printf(" -exheader <exhdr path> ExHeader Template File\n"); printf(" -exheader <exhdr path> ExHeader Template File\n");
printf(" -plain-region <pln region path> PlainRegion File\n"); printf(" -plain-region <pln region path> PlainRegion File\n");
printf(" -romfs <romfs path> RomFS File\n"); printf(" -romfs <romfs path> RomFS File\n");
#endif printf("CCI OPTIONS:\n");
printf("CCI Options:\n"); #ifndef PUBLIC_BUILD
#ifdef PRIVATE_BUILD
printf(" -devcardcci Use SDK CardInfo Method\n"); printf(" -devcardcci Use SDK CardInfo Method\n");
printf(" -omitncchhdr Omit NCCH Hdr for imported NCCH0\n"); printf(" -omitncchhdr Omit NCCH Hdr for imported NCCH0\n");
#endif #endif
printf(" -content <filepath>:<index> Specify content files\n"); printf(" -content <filepath>:<index> Specify content files\n");
printf("CIA Options:\n"); printf("CIA OPTIONS:\n");
#ifdef PRIVATE_BUILD #ifndef PUBLIC_BUILD
printf(" -cci <cci path> Convert CCI to CIA\n"); printf(" -cci <cci path> Convert CCI to CIA\n");
printf(" -srl <srl path> Use TWL SRL as Content0\n"); printf(" -srl <srl path> Use TWL SRL as Content0\n");
#endif #endif
@@ -836,8 +843,5 @@ void DisplayHelp(char *app_name)
printf(" -minor <version minor> Specify Title Version Minor\n"); printf(" -minor <version minor> Specify Title Version Minor\n");
printf(" -micro <version micro> Specify Title Version Micro\n"); printf(" -micro <version micro> Specify Title Version Micro\n");
printf(" -rand Use a random title key\n"); printf(" -rand Use a random title key\n");
printf(" -encryptcia Encrypt CIA Contents\n"); printf(" -nocryptcia Don't encrypt CIA contents\n");
#ifdef RETAIL_FSIGN
printf(" -commonkey <32 hex chars> <id> Specify commonkey and index\n");
#endif
} }
usersettings.h
+22 -33
View File
@@ -15,15 +15,6 @@ typedef enum
USR_MEM_ERROR = -6, USR_MEM_ERROR = -6,
} user_settings_errors; } user_settings_errors;
typedef enum
{
auto_gen,
use_spec_file,
app,
demo,
dlp,
} fixed_accessdesc_type;
typedef enum typedef enum
{ {
format_not_set, format_not_set,
@@ -39,12 +30,12 @@ typedef struct
{ {
struct{ struct{
// Booleans // Booleans
int NoPadding; bool NoPadding; // DELETE
int AllowUnalignedSection; bool AllowUnalignedSection;
int EnableCrypt; bool EnableCrypt;
int EnableCompress; bool EnableCompress;
int FreeProductCode; bool FreeProductCode;
int UseOnSD; bool UseOnSD;
// Strings // Strings
char *PageSize; char *PageSize;
@@ -56,18 +47,18 @@ typedef struct
struct{ struct{
// Booleans // Booleans
int DisableDebug; bool DisableDebug;
int EnableForceDebug; bool EnableForceDebug;
int CanWriteSharedPage; bool CanWriteSharedPage;
int CanUsePrivilegedPriority; bool CanUsePrivilegedPriority;
int CanUseNonAlphabetAndNumber; bool CanUseNonAlphabetAndNumber;
int PermitMainFunctionArgument; bool PermitMainFunctionArgument;
int CanShareDeviceMemory; bool CanShareDeviceMemory;
int UseOtherVariationSaveData; bool UseOtherVariationSaveData;
int UseExtSaveData; bool UseExtSaveData;
int UseExtendedSaveDataAccessControl; bool UseExtendedSaveDataAccessControl;
int RunnableOnSleep; bool RunnableOnSleep;
int SpecialMemoryArrange; bool SpecialMemoryArrange;
// Strings // Strings
char *ProgramId; // DELETE char *ProgramId; // DELETE
@@ -127,7 +118,7 @@ typedef struct
struct{ struct{
// Booleans // Booleans
int MediaFootPadding; bool MediaFootPadding;
// Strings // Strings
char *Title; char *Title;
@@ -136,8 +127,8 @@ typedef struct
char *MediaSize; char *MediaSize;
char *ContentType; char *ContentType;
char *Logo; char *Logo;
char *BackupMemoryType; char *BackupMemoryType;// Delete
char *InitialCode; char *InitialCode;// Delete
} BasicInfo; } BasicInfo;
struct{ struct{
@@ -171,7 +162,7 @@ typedef struct
struct{ struct{
// Strings // Strings
char *Platform; char *Platform; // DELETE
char *Category; char *Category;
char *UniqueId; char *UniqueId;
char *Version; char *Version;
@@ -240,7 +231,6 @@ typedef struct
char *banner_path; char *banner_path;
char *logo_path; char *logo_path;
fixed_accessdesc_type accessdesc;
bool include_exefs_logo; bool include_exefs_logo;
char *exefs_code_path; 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); int ParseArgs(int argc, char *argv[], user_settings *usr_settings);
void ReadYAMLtest(char *filepath); void ReadYAMLtest(char *filepath);
void InvalidateRSFBooleans(rsf_settings *rsf_set);
void free_RsfSettings(rsf_settings *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) int GetYamlSettings(user_settings *set)
{ {
memset(&set->yaml_set,0,sizeof(rsf_settings)); memset(&set->yaml_set,0,sizeof(rsf_settings));
InvalidateRSFBooleans(&set->yaml_set);
int ret = 0; int ret = 0;
if(set->rsf_path) { if(set->rsf_path) {
FILE *tmp = fopen(set->rsf_path,"rb"); 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){ while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return; if(ctx->error || ctx->done) return;
// Handle childs // Handle childs
if(cmpYamlValue("NoPadding",ctx)) rsf->Option.NoPadding = SetBoolYAMLValue("NoPadding",ctx); if(cmpYamlValue("AllowUnalignedSection",ctx)) rsf->Option.AllowUnalignedSection = SetBoolYAMLValue("AllowUnalignedSection",ctx);
else 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("EnableCrypt",ctx)) rsf->Option.EnableCrypt = SetBoolYAMLValue("EnableCrypt",ctx);
else if(cmpYamlValue("EnableCompress",ctx)) rsf->Option.EnableCompress = SetBoolYAMLValue("EnableCompress",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("FreeProductCode",ctx)) rsf->Option.FreeProductCode = SetBoolYAMLValue("FreeProductCode",ctx);
else if(cmpYamlValue("UseOnSD",ctx)) rsf->Option.UseOnSD = SetBoolYAMLValue("UseOnSD",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("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{ else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx)); fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY; 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("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("IdealProcessor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.IdealProcessor,"IdealProcessor",ctx,0);
else if(cmpYamlValue("Priority",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.Priority,"Priority",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); 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("ExtSaveDataId",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ExtSaveDataId,"ExtSaveDataId",ctx,0);
else if(cmpYamlValue("AffinityMask",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.AffinityMask,"AffinityMask",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("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("ResourceLimitCategory",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ResourceLimitCategory,"ResourceLimitCategory",ctx,0);
else if(cmpYamlValue("ReleaseKernelMajor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ReleaseKernelMajor,"ReleaseKernelMajor",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); 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("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("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("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 if(cmpYamlValue("AccessibleSaveDataIds",ctx)) rsf->AccessControlInfo.AccessibleSaveDataIdsNum = SetYAMLSequence(&rsf->AccessControlInfo.AccessibleSaveDataIds,"AccessibleSaveDataIds",ctx);
else{ 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("MediaSize",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.MediaSize,"MediaSize",ctx,0);
else if(cmpYamlValue("ContentType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.ContentType,"ContentType",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("Logo",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.Logo,"Logo",ctx,0);
else if(cmpYamlValue("BackupMemoryType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.BackupMemoryType,"BackupMemoryType",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("InitialCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.InitialCode,"InitialCode",ctx,0);
else{ else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx)); fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY; ctx->error = YAML_UNKNOWN_KEY;
@@ -215,7 +215,7 @@ void GET_Rom(ctr_yaml_context *ctx, rsf_settings *rsf)
// Handle childs // Handle childs
if(cmpYamlValue("HostRoot",ctx)) SetSimpleYAMLValue(&rsf->Rom.HostRoot,"HostRoot",ctx,0); 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("SaveDataSize",ctx)) SetSimpleYAMLValue(&rsf->Rom.SaveDataSize,"SaveDataSize",ctx,0);
else if(cmpYamlValue("DefaultReject",ctx)) rsf->Rom.DefaultRejectNum = SetYAMLSequence(&rsf->Rom.DefaultReject,"DefaultReject",ctx); 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; if(ctx->error || ctx->done) return;
// Handle childs // Handle childs
if(cmpYamlValue("Platform",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Platform,"Platform",ctx,0); if(cmpYamlValue("Category",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Category,"Category",ctx,0);
else 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("UniqueId",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.UniqueId,"UniqueId",ctx,0);
else if(cmpYamlValue("Version",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Version,"Version",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("ContentsIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ContentsIndex,"ContentsIndex",ctx,0);
else if(cmpYamlValue("Variation",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Variation,"Variation",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("ChildIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ChildIndex,"ChildIndex",ctx,0);
else if(cmpYamlValue("DemoIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.DemoIndex,"DemoIndex",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); else if(cmpYamlValue("TargetCategory",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.TargetCategory,"TargetCategory",ctx,0);