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

makerom v0.4

Browse Source
This commit is contained in:
3DSGuy
2014-03-30 16:29:00 +08:00
parent 510988b07a
commit 5150c059cd
52 changed files with 0 additions and 13711 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Application.rsf
-89
View File
@@ -1,89 +0,0 @@
# 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
Application2.rsf
-297
View File
@@ -1,297 +0,0 @@
# 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:
MaxCpu: 0x0 # 0x9E
DisableDebug : true
EnableForceDebug : true
CanWriteSharedPage : true
CanUsePrivilegedPriority : true
CanUseNonAlphabetAndNumber : true
PermitMainFunctionArgument : true
CanShareDeviceMemory : true
#UseOtherVariationSaveData : true
#UseExtSaveData : true
RunnableOnSleep : true
SpecialMemoryArrange : true
#ExtSaveDataId: 0xffffffff
SystemSaveDataId1: 0x220
SystemSaveDataId2: 0x00040010
#OtherUserSaveDataId1: 0x220
#OtherUserSaveDataId2: 0x330
#OtherUserSaveDataId3: 0x440
UseExtendedSaveDataAccessControl: true
AccessibleSaveDataIds: [0x101, 0x202, 0x303, 0x404, 0x505, 0x606]
IoAccessControl:
- FsMountNand # 0x1
- FsMountNandRoWrite #0x2
- FsMountTwln #0x4
- FsMountWnand # 0x8
- FsMountCardSpi #0x10
- UseSdif3 # 0x20
- CreateSeed # 0x40
- UseCardSpi # 0x80
FileSystemAccess:
- CategorySystemApplication #0x1
- CategoryHardwareCheck #0x2
- CategoryFileSystemTool #0x4
- Debug #0x8
- TwlCardBackup #0x10
- TwlNandData #0x20
- Boss #0x40
- DirectSdmc #0x80
- Core #0x100
- CtrNandRo #0x200
- CtrNandRw #0x400
- CtrNandRoWrite #0x800
- CategorySystemSettings #0x1000
- CardBoard #0x2000
- ExportImportIvs #0x4000
- DirectSdmcWrite #0x8000
InterruptNumbers:
- 0x1
AffinityMask: 1
DescVersion: 2
DisableDebug: false
SystemCallAccess:
ArbitrateAddress: 34
Break: 60
CancelTimer: 28
ClearEvent: 25
ClearTimer: 29
CloseHandle: 35
ConnectToPort: 45
ControlMemory: 1
CreateAddressArbiter: 33
CreateEvent: 23
CreateMemoryBlock: 30
CreateMutex: 19
CreateSemaphore: 21
CreateThread: 8
CreateTimer: 26
DuplicateHandle: 39
ExitProcess: 3
ExitThread: 9
GetCurrentProcessorNumber: 17
GetHandleInfo: 41
GetProcessId: 53
GetProcessIdOfThread: 54
GetProcessIdealProcessor: 6
GetProcessInfo: 43
GetResourceLimit: 56
GetResourceLimitCurrentValues: 58
GetResourceLimitLimitValues: 57
GetSystemInfo: 42
GetSystemTick: 40
GetThreadContext: 59
GetThreadId: 55
GetThreadIdealProcessor: 15
GetThreadInfo: 44
GetThreadPriority: 11
MapMemoryBlock: 31
OutputDebugString: 61
QueryMemory: 2
ReleaseMutex: 20
ReleaseSemaphore: 22
SendSyncRequest1: 46
SendSyncRequest2: 47
SendSyncRequest3: 48
SendSyncRequest4: 49
SendSyncRequest: 50
SetThreadPriority: 12
SetTimer: 27
SignalEvent: 24
SleepThread: 10
UnmapMemoryBlock: 32
WaitSynchronization1: 36
WaitSynchronizationN: 37
HandleTableSize: 512
IORegisterMapping:
- 1ff50000-1ff57fff
- 1ff70000-1ff77fff
IdealProcessor: 0
MemoryMapping:
- 1f000000-1f5fffff:r
MemoryType: Application
Priority: 16
ProgramId: 0x00040000ffffff00L
ReleaseKernelMajor: "02"
ReleaseKernelMinor: "33"
ServiceAccessControl:
- APT:U
- $hioFIO
- $hostio0
- $hostio1
- ac:u
- boss:U
- cam:u
- cecd:u
- cfg:u
- dlp:FKCL
- dlp:SRVR
- dsp::DSP
- frd:u
- fs:USER
- gsp::Gpu
- hid:USER
- http:C
- mic:u
- ndm:u
- news:u
- nwm::UDS
- ptm:u
- pxi:dev
- soc:U
- ssl:C
- y2r:u
- ldr:ro
- ir:USER
CoreVersion: 2
StorageId:
- 0
SystemControlInfo:
RemasterVersion: 5
Dependency:
ac: 0x0004013000002402L
am: 0x0004013000001502L
boss: 0x0004013000003402L
camera: 0x0004013000001602L
cecd: 0x0004013000002602L
cfg: 0x0004013000001702L
codec: 0x0004013000001802L
csnd: 0x0004013000002702L
dlp: 0x0004013000002802L
dsp: 0x0004013000001a02L
friends: 0x0004013000003202L
gpio: 0x0004013000001b02L
gsp: 0x0004013000001c02L
hid: 0x0004013000001d02L
http: 0x0004013000002902L
i2c: 0x0004013000001e02L
ir: 0x0004013000003302L
mcu: 0x0004013000001f02L
mic: 0x0004013000002002L
ndm: 0x0004013000002b02L
news: 0x0004013000003502L
nim: 0x0004013000002c02L
nwm: 0x0004013000002d02L
pdn: 0x0004013000002102L
ps: 0x0004013000003102L
ptm: 0x0004013000002202L
ro: 0x0004013000003702L
socket: 0x0004013000002e02L
spi: 0x0004013000002302L
ssl: 0x0004013000002f02L
StackSize: 0x40000
CommonHeaderKey:
D: |
jL2yO86eUQnYbXIrzgFVMm7FVze0LglZ2f5g+c42hWoEdnb5BOotaMQPBfqt
aUyAEmzQPaoi/4l4V+hTJRXQfthVRqIEx27B84l8LA6Tl5Fy9PaQaQ+4yRfP
g6ylH2l0EikrIVjy2uMlFgl0QJCrG+QGKHftxhaGCifdAwFNmiZuyJ/TmktZ
0RCb66lYcr2h/p2G7SnpKUliS9h9KnpmG+UEgVYQUK+4SCfByUa9PxYGpT0E
nw1UcRz0gsBmdOqcgzwnAd9vVqgb42hVn6uQZyAl+j1RKiMWywZarazIR/k5
Lmr4+groimSEa+3ajyoIho9WaWTDmFU3mkhA2tUDIQ==
DP: |
pD8c9uymjXDj6oyhx7EmQcrEDizxsj6hTjJ0x3G/PYNv/v2/DA9gp3X30h35
uRZ1O+SgonWCGVnOJ7Wfjr4w2cOcSzxpzT3PQsS6Gs9z0RvcDsUHRL5f2EiT
6A1ZPj6xyzmo9Ts6w9yfxCwaHci0f2hP9bq9FimfFKigCoNcFBE=
DQ: |
y+6Pado7N+SIZJgQ7zEGyQ7/SxGHHEy5uW04HHde9IqHD5HFGG2GegF655mM
iI9ja1eTCh/AFs8xjAg0drQEvB5q80TjPNKtwVUT8ghOlN3xTzpdaLwX0d+c
Twy74VY4KPawcdDeLaGFtXknhFOdGmIbx+BInibz7NZ9eLqGwaE=
Exponent: |
AQAB
InverseQ: |
tc9/lcF837g8AdfyeuCyuLyd36Zm1ZmJ1VSSuH8y3/1ZhBYZkOFXxU7EhMvJ
FyAu4qyCA9otzCXM+cqKxE3ZCkSconsXOu8szZTwuINSkwHlt22FtiTfPt+V
/g5kjtkjoZVOGfSvvfel9Smwy1yrFvKfi/yJsjATeNFjiEquV/w=
Modulus: |
z+yySANtuAnjXGxiLKlJ4fT0DGzD5S+dUKArWgDGcgALowRdlEbnABtIhbVh
LMl0yitDE8F4l1wzLwfHhfDa22CWUA98S3rXF53k5cOrb12leDKtBN2Wbtx1
/8Iv+qLuRonNrmmSpEi8RkfEjIlj4QpNHNxGL1twinzpIpwJC6iXQMoqfYSh
BEou29fQZEOc0HgRQYgz3TFikC0X8sapK5xwq9zTq13a7j1sDoH/9mdaRPms
Bz0jlHVlkyAMxXYdD2UGPSGi8JaAtwpJUzijXcB0PKTZQDaFH4zRLRX57ySp
fp2yHvigcoEXd3OxVn+tBaLSMFr1068PEEpS2AlHlw==
P: |
6SdD3AiAybNamgUgGJduyFWO1/LeakmoJm+23IEJADyU4nz+reGjxQnMrR+x
syuB8VPGuf1z0SInfRIu9PEjIfW9/H/fZ59GwckQuJbneODjW7KU1jM3cTVX
+AWvaxWDwlCUmVSYD2OySUJlo3szGmBYh/o/tKAq7kElaaOt+cc=
Q: |
5EyO8bCyfqgLTfipAG/nNLObQbqMyARdQfudxh4eQqHmzblEM3jareuA8eUZ
K8pIaP+U9UfxwWTeFsOulrpsm04j4gS71WGNx3YwOIRPXXOn7zBkxA3AO9qq
K8lMeV3gNsdt4Fz8Zh2F68HSP4avB+ThO2S18SXMyIkcM7Sbw7E=
Signature: |
3xyLmORvojVswxgXmPPOVH4ULn8e2G3PvClO/jIuwRGtRprGcOruKFUi4TYF
HASKzg8Mg4/I1t4RjurPrZvPgQ3rcROz066DAkwOEFBZPO5gBvuMf8IgJAFi
VYdgD636cy72ZWLS5RBFaXA5A9E57FDB1CU5spARTpXLGevKD7X6x7Di1+Bx
w+VVM55c3E07URENMXiWytcYWO4A6SjyaHbUV/5lsUtJP/amWErH/MS7YbxY
jVVl5gp5OUG4gGH3BcP+1osJgsJfplb57h0OBj6fP/GTmk+i1ZGHiv7Pw/yK
scR46dEa97HTIMuDvgPVyqVeF6aRENS+I9ZLTwOprg==
Descriptor: |
AP///wAABAACAAAAAAAFGJ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIAAAAAAAABBUFQ6VQAAACRo
aW9GSU8AJGhvc3RpbzAkaG9zdGlvMWFjOnUAAAAAYm9zczpVAABjYW06dQAA
AGNlY2Q6dQAAY2ZnOnUAAABkbHA6RktDTGRscDpTUlZSZHNwOjpEU1BmcmQ6
dQAAAGZzOlVTRVIAZ3NwOjpHcHVoaWQ6VVNFUmh0dHA6QwAAbWljOnUAAABu
ZG06dQAAAG5ld3M6dQAAbndtOjpVRFNwdG06dQAAAHB4aTpkZXYAc29jOlUA
AABzc2w6QwAAAHkycjp1AAAAbGRyOnJvAABpcjpVU0VSAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAABOn/rw/7//8ec/APIA8JH/APaR/1D/gf9Y/4H/cP+B/3j/gf8B
AQD/AAIA/iECAPz/////////////////////////////////////////////
////////////////////////////////////////AAAAAAAAAAAAAAAAAAAA
AAADAAAAAAAAAAAAAAAAAAI=
makerom.h → Forgot to backup source
View File
Makefile
-58
View File
@@ -1,58 +0,0 @@
# Makerom Sources
UTILS_OBJS = utils.o keyset.o titleid.o
CIA_OBJS = cia.o certs.o tik.o tmd.o
NCCH_OBJS = ncch.o exheader.o exefs.o elf.o romfs.o
NCSD_OBJS = ncsd.o
SETTINGS_OBJS = usersettings.o yamlsettings.o
LIB_API_OBJS = crypto.o yaml_ctr.o blz.o
OBJS = makerom.o $(UTILS_OBJS) $(LIB_API_OBJS) $(SETTINGS_OBJS) $(NCSD_OBJS) $(NCCH_OBJS) $(CIA_OBJS)
# Libraries
POLAR_OBJS = polarssl/aes.o polarssl/bignum.o polarssl/rsa.o polarssl/sha1.o polarssl/sha2.o polarssl/padlock.o polarssl/md.o polarssl/md_wrap.o polarssl/md2.o polarssl/md4.o polarssl/md5.o polarssl/sha4.o polarssl/base64.o polarssl/cipher.o polarssl/cipher_wrap.o polarssl/camellia.o polarssl/des.o polarssl/blowfish.o
YAML_OBJS = libyaml/api.o libyaml/dumper.o libyaml/emitter.o libyaml/loader.o libyaml/parser.o libyaml/reader.o libyaml/scanner.o libyaml/writer.o
# Compiler Settings
LIBS = -static-libgcc -static-libstdc++
CXXFLAGS = -I.
CFLAGS = --std=c99 -Wall -I. -DMAKEROM_VER_MAJOR=$(VER_MAJOR) -DMAKEROM_VER_MINOR=$(VER_MINOR) $(MAKEROM_BUILD_FLAGS)
CC = gcc
# MAKEROM Build Settings
MAKEROM_BUILD_FLAGS = #-DDEBUG #-DELF_DEBUG
VER_MAJOR = 0
VER_MINOR = 3
OUTPUT = makerom
main: build
rebuild: clean build
build: $(OBJS) $(POLAR_OBJS) $(YAML_OBJS)
g++ -o $(OUTPUT) $(LIBS) $(OBJS) $(POLAR_OBJS) $(YAML_OBJS)
clean:
rm -rf $(OUTPUT) $(OBJS) $(POLAR_OBJS) $(YAML_OBJS) *.cci *.cia *.cxi *.cfa
# Winfail compatibility
rebuildwin: cleanwin build
cleanwin:
del /Q objs $(OUTPUT).exe *.o polarssl\*.o libyaml\*.o *.cci *.cia *.cxi *.cfa
#Test Functions
ccigen_sdk:
ctr_makerom32 -f card -rsf testdata\Application.rsf -o content_test_sdk.cci -content testdata\app_zeroskey.cxi:0 -content testdata\manual_zeroskey.cfa:1 -content testdata\dlp_zeroskey.cfa:2 -content testdata\update_zeroskey.cfa:7
del content_test_sdk.cci.xml
ccigen:
$(OUTPUT) -f card -rsf testdata\Application.rsf -o content_test.cci -content testdata\app_zeroskey.cxi:0 -content testdata\manual_zeroskey.cfa:1 -content testdata\dlp_zeroskey.cfa:2 -content testdata\update_zeroskey.cfa:7
ciagen_sdk:
ctr_makecia32 -o content_test.cia -i testdata\app_zeroskey.cxi:0 -i testdata\manual_zeroskey.cfa:1 -i testdata\dlp_zeroskey.cfa:2
ciagen:
$(OUTPUT) -f cia -o content_test.cia -content testdata\app_zeroskey.cxi:0 -content testdata\manual_zeroskey.cfa:1 -content testdata\dlp_zeroskey.cfa:2 -encryptcia
pyramids:
$(OUTPUT) -f cxi -accessdesc app -o pyramids.cxi -code pyramids\code.bin -exheader pyramids\exheader.bin -rsf pyramids\app.rsf -desc pyramids\build.desc -icon pyramids\icon.icn -banner pyramids\banner.bnr -romfs pyramids\romfs.bin
accessdesc_sig.h
-320
View File
@@ -1,320 +0,0 @@
#ifndef _ACCESSDESC_SIG_H_
#define _ACCESSDESC_SIG_H_
/* CTR_SDK 1 (1.2.0) */
// DependencyList
static const unsigned char sdk1_dep_list[0x180] =
{
0x02, 0x24, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x15, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x34, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x16, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x26, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x17, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x18, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x27, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x28, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1A, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x32, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x29, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x20, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x35, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x21, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x31, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x22, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x23, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// APP
static const unsigned char App_sdk1_HdrPubK[0x100] =
{
0x9B, 0x82, 0x9C, 0x19, 0x01, 0x73, 0x23, 0x50, 0x89, 0xE3, 0x0B, 0xC8, 0x8F, 0xFB, 0xA5, 0xE4, 0xFD, 0x44, 0xAE, 0x49, 0x32, 0xC7, 0xEF, 0x0A, 0x7E, 0x93, 0x95, 0xBA, 0xA2, 0x48, 0x4D, 0x8E, 0x18, 0x82, 0x34, 0x66, 0xFE, 0xDA, 0x7A, 0x45, 0x4A, 0x7D, 0xD5, 0x3C, 0xC6, 0x5C, 0xE0, 0x71, 0xFC, 0xD0, 0x82, 0xCC, 0xB2, 0xCF, 0x77, 0x0E, 0xAD, 0xCD, 0xD2, 0xAC, 0x1D, 0x66, 0x1B, 0xC1, 0xEA, 0xAC, 0x39, 0x96, 0x2C, 0x52, 0xDE, 0xFF, 0xF2, 0x74, 0xF6, 0xC5, 0xCA, 0x99, 0x31, 0x95, 0x13, 0xBB, 0x3F, 0xED, 0x30, 0xAE, 0x0A, 0xD3, 0x86, 0x0D, 0x0B, 0xF5, 0x56, 0x7D, 0x33, 0xBA, 0xA1, 0x39, 0xA2, 0xF5, 0xB6, 0x47, 0x78, 0x1F, 0xFD, 0x04, 0xA3, 0x49, 0xA9, 0x10, 0xD3, 0x41, 0x2E, 0x92, 0x7D, 0xE1, 0xA4, 0xA8, 0x02, 0x18, 0x01, 0x2C, 0xC2, 0x61, 0xB1, 0xAC, 0xCB, 0xB3, 0x7A, 0x64, 0xB1, 0xC3, 0xE6, 0x3B, 0x50, 0xAD, 0xDD, 0x55, 0xAB, 0x28, 0xDA, 0x59, 0xE7, 0x57, 0x6A, 0x76, 0x4F, 0x6B, 0x08, 0xD1, 0x61, 0x7D, 0x28, 0xD5, 0x88, 0x7B, 0x8E, 0x80, 0x78, 0xF3, 0xFF, 0x50, 0x00, 0xBD, 0x73, 0xFB, 0x62, 0xB3, 0xCA, 0xA8, 0x05, 0x48, 0xE6, 0xE6, 0x71, 0xB5, 0xAC, 0xDA, 0xE9, 0xC6, 0x1F, 0x9B, 0x72, 0x98, 0x2E, 0xFF, 0xB2, 0x9C, 0x36, 0x9F, 0x7E, 0x7D, 0x25, 0x65, 0x6F, 0xB0, 0x60, 0xB1, 0xB5, 0x5F, 0xCF, 0x74, 0x29, 0x91, 0x9D, 0xAB, 0x84, 0x97, 0x1A, 0x27, 0x5D, 0x69, 0x49, 0x16, 0xF8, 0x77, 0x31, 0x26, 0x3E, 0x6F, 0x97, 0x41, 0x4A, 0x26, 0xFD, 0x5B, 0xAB, 0x65, 0x77, 0x45, 0x1C, 0x76, 0x15, 0xDC, 0x1A, 0x63, 0x0F, 0x51, 0x2D, 0xA0, 0x07, 0x6E, 0xE5, 0x29, 0xD3, 0x37, 0x4B, 0xE5, 0x7F, 0xBB, 0x23, 0xD0, 0x2B, 0xB9, 0x76, 0x1F
};
static const unsigned char App_sdk1_HdrPrivK[0x100] =
{
0x66, 0x9F, 0xB5, 0xC5, 0xA6, 0xB8, 0x45, 0xD8, 0xD3, 0x75, 0xFB, 0x03, 0xBB, 0x48, 0xF5, 0x7C, 0x7D, 0x4B, 0x02, 0xBD, 0x19, 0x7E, 0xE9, 0x98, 0x02, 0x5A, 0x00, 0xD8, 0x6E, 0x59, 0xCA, 0x9C, 0x78, 0x3E, 0x0C, 0xB8, 0xDF, 0x7C, 0x6C, 0x6E, 0x27, 0xAF, 0x8C, 0xB6, 0x13, 0xAD, 0x9D, 0x0C, 0x7C, 0x2B, 0x59, 0xF6, 0x1E, 0x16, 0x5D, 0x5A, 0x59, 0x86, 0x57, 0x7D, 0xEF, 0xD4, 0xBF, 0x82, 0xA4, 0x0C, 0x4D, 0xE0, 0x75, 0x95, 0xA6, 0xC6, 0x3F, 0x49, 0xC2, 0xC4, 0x5A, 0x63, 0xE8, 0x5D, 0x99, 0xEC, 0xDB, 0x4D, 0xFA, 0xEF, 0x10, 0x03, 0xF1, 0x15, 0xD1, 0x0B, 0x71, 0xAD, 0x24, 0x23, 0x08, 0x5C, 0x91, 0xD7, 0x17, 0x18, 0x69, 0x04, 0xAB, 0x23, 0x91, 0x62, 0x7D, 0xE8, 0xB5, 0x90, 0xF1, 0x5C, 0x09, 0x28, 0x8C, 0x51, 0xB7, 0x38, 0x02, 0x26, 0x78, 0x8C, 0xA2, 0x05, 0x07, 0x53, 0x7D, 0x99, 0x46, 0xFD, 0x12, 0x77, 0x32, 0x0E, 0xA8, 0x54, 0xE3, 0x32, 0x0E, 0x93, 0x05, 0x10, 0xFA, 0x59, 0x7A, 0x5D, 0x2E, 0xDE, 0x32, 0xE8, 0xE9, 0xF0, 0x27, 0x4E, 0x08, 0x83, 0x08, 0xD4, 0x92, 0x58, 0x4D, 0x6D, 0x34, 0x9F, 0xD9, 0xAF, 0xA9, 0x01, 0x62, 0xB5, 0x1A, 0x1D, 0x7E, 0x8D, 0xBB, 0x8A, 0x58, 0xBA, 0xFF, 0xB4, 0xD3, 0x75, 0xF3, 0x44, 0xE7, 0x13, 0x05, 0xC6, 0xC5, 0xA4, 0xD2, 0x6B, 0x18, 0x31, 0x9F, 0xBE, 0x42, 0x45, 0x82, 0x2E, 0x47, 0x9B, 0x26, 0x73, 0x28, 0xD7, 0x9A, 0x64, 0xA6, 0x3D, 0x38, 0x9C, 0x11, 0x36, 0x01, 0x5B, 0x82, 0x2F, 0x7E, 0xA8, 0xC4, 0x82, 0x15, 0x6C, 0x0B, 0xBA, 0x1C, 0x58, 0xF5, 0x81, 0xF9, 0x45, 0xA9, 0xC6, 0x05, 0x6A, 0x2C, 0xA6, 0xCF, 0xF5, 0xDF, 0xEB, 0xBB, 0xC0, 0x92, 0xE3, 0xA6, 0x9D, 0x23, 0x09, 0x09, 0x0E, 0x98, 0x39
};
static const unsigned char App_sdk1_AcexData[0x200] =
{
0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFB, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char App_sdk1_AcexSig[0x100] =
{
0x05, 0x90, 0xAF, 0x65, 0x16, 0x9F, 0x18, 0x2C, 0x17, 0x78, 0x9F, 0xDF, 0xB6, 0x37, 0xCF, 0x26, 0x9B, 0x1B, 0x75, 0x51, 0xB8, 0x57, 0xA3, 0x8F, 0xD7, 0x93, 0x19, 0x61, 0x81, 0x0D, 0x3D, 0xBC, 0x36, 0x50, 0x53, 0xDA, 0x7D, 0xA9, 0x7F, 0xAA, 0x3E, 0x51, 0x2C, 0x75, 0xA1, 0xB9, 0xB1, 0x56, 0xEB, 0x2A, 0x46, 0x21, 0xEC, 0x4F, 0xA7, 0x0C, 0xA1, 0xA8, 0xFD, 0xEE, 0xA3, 0x4A, 0xFD, 0x54, 0xB0, 0x3A, 0x49, 0x5C, 0x8F, 0x8D, 0xB2, 0xBC, 0x32, 0x50, 0x7E, 0x2C, 0x50, 0xD2, 0x1A, 0x6B, 0x61, 0xCB, 0x2A, 0xC9, 0x7E, 0x6E, 0x6A, 0xC8, 0xD6, 0x9B, 0x21, 0xE7, 0x3B, 0xB8, 0x39, 0x1C, 0xD7, 0xEB, 0x69, 0x35, 0xF5, 0xBC, 0xB5, 0x23, 0x54, 0x81, 0x4F, 0x73, 0xAB, 0x9C, 0x55, 0xF0, 0x04, 0x0B, 0x4A, 0xEA, 0x54, 0x08, 0xBF, 0x36, 0x28, 0x12, 0x5E, 0x44, 0x41, 0xF5, 0x3D, 0xFE, 0xA7, 0x6B, 0x35, 0xF2, 0x9A, 0xF2, 0x88, 0xCD, 0xD6, 0x2E, 0x7B, 0xF3, 0xF5, 0x0D, 0x06, 0x2E, 0x13, 0x4F, 0x78, 0xEE, 0x27, 0xAB, 0x31, 0x06, 0x62, 0xE9, 0xB2, 0x3E, 0xC6, 0x99, 0xD7, 0xA9, 0xCC, 0x21, 0x70, 0xD7, 0xCD, 0x9F, 0x03, 0x66, 0x91, 0x7E, 0xBD, 0x3E, 0x83, 0xC4, 0xFF, 0xC9, 0xAA, 0x7E, 0x27, 0xAE, 0x5C, 0x37, 0x7D, 0x93, 0x57, 0x60, 0xB9, 0x0B, 0x71, 0x43, 0x8A, 0x2F, 0x43, 0x50, 0x94, 0xF8, 0x0D, 0x40, 0xCC, 0x64, 0x16, 0x09, 0x70, 0xCD, 0x03, 0xCA, 0x95, 0x30, 0x20, 0xE2, 0x85, 0x2F, 0x2A, 0xCF, 0x65, 0xAA, 0xE9, 0xCF, 0x1F, 0x57, 0xC1, 0x8F, 0xD5, 0x46, 0x51, 0x5A, 0x99, 0x60, 0x65, 0x93, 0xA9, 0xBB, 0xEA, 0x5F, 0xA0, 0x47, 0xD7, 0x11, 0x04, 0xC7, 0xB4, 0x82, 0x66, 0x24, 0x17, 0x17, 0x5E, 0x9D, 0xC8, 0x50, 0x80, 0x63, 0x28, 0xB3, 0xF8, 0xE3
};
// DLP
static const unsigned char Dlp_sdk1_HdrPubK[0x100] =
{
0xD9, 0xF0, 0xC9, 0x35, 0x1E, 0x55, 0xD8, 0x7E, 0x96, 0x53, 0x33, 0x34, 0xBB, 0x8A, 0xAE, 0x03, 0x92, 0x35, 0xE2, 0x05, 0x58, 0x7C, 0xCC, 0x08, 0xB2, 0xDF, 0x43, 0x41, 0xB7, 0x7A, 0xB5, 0x29, 0xEE, 0x4E, 0xF3, 0xC7, 0x35, 0x3B, 0x7E, 0xC5, 0xEE, 0x74, 0xF0, 0xAA, 0x7E, 0x60, 0xF1, 0x28, 0x35, 0x17, 0xD6, 0xC9, 0x9A, 0xF2, 0x84, 0xFE, 0xC8, 0x93, 0x86, 0xF7, 0xA7, 0x36, 0xA6, 0xB0, 0x28, 0xDC, 0xE8, 0x38, 0x0B, 0x54, 0x42, 0x8D, 0x4E, 0x4B, 0x55, 0x0F, 0x4A, 0x0D, 0x72, 0xA0, 0x23, 0xC9, 0x68, 0x22, 0x37, 0x31, 0x88, 0x2C, 0x05, 0x49, 0x86, 0x80, 0x9A, 0xFC, 0x1D, 0x02, 0xE3, 0x20, 0x15, 0x0C, 0x7E, 0x28, 0x40, 0x57, 0xEF, 0xA7, 0xBC, 0xAA, 0xC5, 0xD6, 0xD7, 0x6F, 0xF9, 0x26, 0x9A, 0x32, 0xB2, 0x9E, 0x10, 0x5F, 0x93, 0xE6, 0xB2, 0xC6, 0xB2, 0x62, 0x34, 0x6A, 0xB0, 0xD9, 0x71, 0x3B, 0x0F, 0x34, 0x6C, 0xB1, 0xFE, 0x3A, 0x39, 0xDE, 0x3D, 0x6A, 0xCB, 0x32, 0x95, 0xFA, 0x18, 0x4F, 0xF4, 0xEB, 0x5F, 0x20, 0xE4, 0xEF, 0x64, 0xC5, 0x06, 0x27, 0xC3, 0x44, 0x2A, 0x39, 0x35, 0xD8, 0x00, 0xDF, 0x00, 0xAD, 0xC4, 0x98, 0x06, 0x52, 0xD8, 0x4A, 0xC5, 0x2A, 0x7F, 0x77, 0x50, 0x62, 0x7E, 0x05, 0x3E, 0x8C, 0x28, 0x0A, 0x26, 0xD2, 0x6C, 0x9B, 0x27, 0x65, 0xE9, 0x77, 0x68, 0xE9, 0xE6, 0xAA, 0xBA, 0xF5, 0x85, 0xFC, 0x75, 0x07, 0x84, 0xB2, 0xCA, 0x35, 0x85, 0x52, 0x10, 0x08, 0xEF, 0x85, 0xD3, 0x70, 0x17, 0x31, 0xE1, 0x44, 0xF6, 0x34, 0xDF, 0x7C, 0x42, 0xF7, 0x74, 0xAA, 0xFC, 0xC3, 0xE4, 0x84, 0x2D, 0xBF, 0x15, 0x1E, 0x84, 0x00, 0xE3, 0x80, 0xD7, 0x89, 0x56, 0xEE, 0x60, 0x09, 0x1F, 0xD3, 0xBF, 0xBF, 0x50, 0x8F, 0xA3, 0x0C, 0x72, 0x3F
};
static const unsigned char Dlp_sdk1_HdrPrivK[0x100] =
{
0x10, 0x19, 0x3A, 0x33, 0xA3, 0x47, 0x02, 0x13, 0xEF, 0xB4, 0xBB, 0x9E, 0x94, 0x8F, 0xDC, 0xE4, 0xC4, 0xA3, 0x18, 0x4B, 0xFE, 0xCA, 0x51, 0x23, 0xFF, 0x5A, 0x80, 0x94, 0x55, 0x22, 0x4A, 0x49, 0x8B, 0xA1, 0xE7, 0x5D, 0xFA, 0xAF, 0xA7, 0x60, 0xA5, 0x89, 0x9B, 0xD1, 0x6C, 0x3E, 0x6A, 0xF1, 0xE6, 0x62, 0x19, 0x6A, 0x90, 0xF8, 0x83, 0x1C, 0x72, 0xE2, 0x7A, 0xE0, 0xC6, 0x48, 0x42, 0x2D, 0xD7, 0x06, 0xE2, 0x5C, 0x69, 0x71, 0xD2, 0xEC, 0xAF, 0x30, 0xDF, 0x5A, 0x9E, 0xC4, 0xB9, 0x87, 0xDC, 0xBC, 0xDE, 0xE5, 0x50, 0x20, 0x67, 0x87, 0xA0, 0xE8, 0x5A, 0x78, 0x1B, 0x7A, 0xAE, 0x05, 0xED, 0x93, 0x0C, 0x1A, 0xFD, 0x22, 0xAA, 0x06, 0x14, 0xDC, 0xD6, 0x11, 0xE3, 0x45, 0x48, 0x6A, 0xAC, 0x03, 0xCE, 0xF6, 0x19, 0xBD, 0x95, 0x46, 0x0A, 0x1D, 0xCB, 0x6C, 0xE3, 0xF6, 0x5F, 0x1A, 0xB3, 0x81, 0xC7, 0xE2, 0xAB, 0xFE, 0xEF, 0xFB, 0xEC, 0xFE, 0x88, 0x36, 0x26, 0x60, 0x47, 0x43, 0x78, 0x36, 0xA7, 0xC8, 0xC9, 0x40, 0x98, 0x2E, 0xF2, 0x7E, 0xE4, 0x0D, 0x6C, 0x45, 0x88, 0x2A, 0x32, 0x9B, 0xA2, 0x7C, 0x39, 0x20, 0xAA, 0x6B, 0x64, 0x35, 0xC6, 0xA9, 0x20, 0x71, 0x4A, 0x78, 0x6E, 0x55, 0x3C, 0x9B, 0xEA, 0x10, 0x73, 0xBB, 0xA7, 0xD8, 0xFE, 0x69, 0x42, 0xB8, 0xE7, 0xA1, 0xE5, 0xDF, 0x8A, 0xDE, 0x4C, 0x2B, 0x3A, 0x92, 0xB8, 0x3E, 0x5E, 0x2C, 0x29, 0x0D, 0xC1, 0x3D, 0x10, 0x65, 0x1E, 0xF1, 0x95, 0xE5, 0xF6, 0x45, 0x15, 0xBF, 0xE2, 0x30, 0xA6, 0x70, 0x19, 0xA4, 0x11, 0x57, 0x12, 0x1C, 0x81, 0x4B, 0x54, 0x04, 0xBE, 0x67, 0xF5, 0x00, 0x22, 0x06, 0xDA, 0x6B, 0xCE, 0x23, 0x3F, 0x86, 0xE4, 0x70, 0x6A, 0xD1, 0x3E, 0xE5, 0x74, 0x44, 0x86, 0xDA, 0xBE, 0x79
};
static const unsigned char Dlp_sdk1_AcexData[0x200] =
{
0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFB, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char Dlp_sdk1_AcexSig[0x100] =
{
0x13, 0xB2, 0xF4, 0x89, 0xBB, 0xB4, 0xFF, 0x55, 0x7E, 0x3E, 0x9B, 0x90, 0x44, 0x45, 0xC6, 0x8A, 0x17, 0x32, 0x91, 0x77, 0x7D, 0xCB, 0x4A, 0x26, 0x3D, 0xCA, 0xD8, 0x6E, 0x72, 0x27, 0x93, 0x9C, 0xE4, 0x27, 0xFE, 0x54, 0xDC, 0xE7, 0xDC, 0x02, 0x17, 0x9C, 0x82, 0xA8, 0xB0, 0xE8, 0x69, 0x07, 0xE3, 0x34, 0x0E, 0xBF, 0x17, 0x05, 0x58, 0x23, 0x5F, 0x6D, 0xDA, 0xE8, 0xC6, 0xEE, 0x49, 0x29, 0xEF, 0xD7, 0x48, 0x48, 0x41, 0xE2, 0x2A, 0x57, 0x2B, 0x21, 0x13, 0x64, 0xD4, 0x79, 0x5A, 0xE3, 0x84, 0xDA, 0x63, 0x9A, 0x07, 0x39, 0xE2, 0x7E, 0xA7, 0x56, 0x34, 0x1C, 0xE2, 0xAF, 0xCD, 0x65, 0xD1, 0xC0, 0x1B, 0x72, 0xB1, 0x1D, 0xFC, 0xE2, 0x6E, 0x0F, 0xC7, 0xB0, 0xF5, 0x84, 0x0F, 0xA5, 0x2B, 0xDF, 0x3A, 0xCF, 0x43, 0xE8, 0xE4, 0x07, 0x29, 0xC6, 0x41, 0x0E, 0x7B, 0xEE, 0x35, 0xF9, 0xFC, 0xE7, 0x15, 0xF3, 0x8C, 0x3A, 0xB4, 0x77, 0xBD, 0x88, 0x70, 0x83, 0x4A, 0x03, 0x9E, 0x01, 0x9B, 0xBB, 0xD2, 0xE4, 0xA5, 0xBE, 0xF7, 0x80, 0x92, 0x5A, 0x9F, 0x14, 0x9B, 0x49, 0x5D, 0x3D, 0xDC, 0x32, 0x34, 0x7E, 0xC0, 0xD4, 0xAC, 0xDA, 0x8C, 0xF7, 0xA1, 0xE1, 0xCA, 0x29, 0xF5, 0x58, 0x5E, 0xEB, 0x02, 0xB6, 0x67, 0x42, 0x89, 0x46, 0x4C, 0xA6, 0xA8, 0xBD, 0xEB, 0xEB, 0xDD, 0x8F, 0x2E, 0x72, 0x26, 0x49, 0x70, 0x01, 0x7D, 0x5B, 0x03, 0x06, 0x2C, 0x92, 0x1E, 0x55, 0xB2, 0xDA, 0xD7, 0x0D, 0x70, 0x74, 0x42, 0xD5, 0x62, 0x42, 0x3C, 0xC1, 0x70, 0x8E, 0x67, 0xB1, 0xD9, 0xF3, 0x7E, 0xB2, 0xBA, 0x6D, 0x0F, 0x42, 0x65, 0x24, 0x79, 0xE8, 0x8F, 0xB4, 0x4B, 0x32, 0x35, 0xCA, 0x39, 0x70, 0xFE, 0x8E, 0x81, 0x49, 0x73, 0x8D, 0x3C, 0xCD, 0x60, 0xAF, 0xA3, 0x52, 0x45, 0xEE
};
/* CTR_SDK 2 (2.3.4) */
static const unsigned char sdk2_dep_list[0x180] =
{
0x02, 0x24, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x15, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x34, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x16, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x26, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x17, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x18, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x27, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x28, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1A, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x32, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x29, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x20, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x35, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x21, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x31, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x22, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x23, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// APP
static const unsigned char App_sdk2_HdrPubK[0x100] =
{
0xE9, 0x45, 0xF0, 0xC6, 0x96, 0xD5, 0x6F, 0x7E, 0xAE, 0x03, 0x92, 0x2E, 0xEA, 0xCB, 0xFD, 0xEA, 0xA4, 0x7A, 0x9F, 0x12, 0xDA, 0x4C, 0x10, 0x0A, 0xBE, 0x08, 0x9D, 0x87, 0xE0, 0x14, 0xAC, 0x7F, 0x39, 0xD2, 0xFE, 0x9D, 0x88, 0xB2, 0x81, 0xF6, 0x1A, 0x9E, 0x15, 0x57, 0xD4, 0xE2, 0x31, 0x08, 0x07, 0xEC, 0x4F, 0x10, 0x00, 0xDE, 0xEF, 0x8B, 0x6F, 0xCF, 0x84, 0xE7, 0x3B, 0x41, 0x08, 0x64, 0x3B, 0x1C, 0x00, 0x7C, 0x73, 0xBB, 0x59, 0x4D, 0xD8, 0xD6, 0xE7, 0x7B, 0xBE, 0xDD, 0x50, 0x98, 0xA1, 0x1A, 0xD5, 0xAA, 0x37, 0x69, 0xB8, 0x25, 0xCB, 0x7B, 0x03, 0x00, 0x90, 0x25, 0xF3, 0x7E, 0x9A, 0x0F, 0xA3, 0xAA, 0xC4, 0xB9, 0x3B, 0x3A, 0x18, 0x2B, 0xBC, 0x9C, 0x11, 0x04, 0x92, 0x16, 0x6E, 0xC3, 0xFA, 0x01, 0xD3, 0x00, 0x02, 0xF3, 0x2E, 0xD5, 0x60, 0xA8, 0xAF, 0xAB, 0xEE, 0x2F, 0x9D, 0x30, 0x3E, 0x0E, 0xDC, 0xB8, 0xEC, 0x87, 0x9E, 0x4A, 0xA9, 0x01, 0x34, 0x69, 0x2C, 0x4C, 0x34, 0xB7, 0x7D, 0xB9, 0x7A, 0x17, 0x74, 0x31, 0xB0, 0x29, 0xC4, 0x7D, 0x27, 0x1F, 0xBA, 0xBA, 0x3F, 0x5B, 0x62, 0xF6, 0x90, 0xB8, 0x37, 0x33, 0xFC, 0x73, 0xD6, 0x19, 0x11, 0xCA, 0x83, 0x2A, 0x58, 0x62, 0x9C, 0xB1, 0x83, 0x43, 0x1D, 0x2C, 0x00, 0xA2, 0xE5, 0x87, 0x97, 0x12, 0x63, 0x31, 0x83, 0x0E, 0xB1, 0x1E, 0x69, 0x99, 0x02, 0xAF, 0xDF, 0xFF, 0x0F, 0xA9, 0x7C, 0x1B, 0x33, 0x9E, 0xFF, 0x9C, 0x14, 0x19, 0xA6, 0xCA, 0xFD, 0xB9, 0x17, 0xE0, 0x22, 0xCF, 0xB5, 0x00, 0x77, 0x2E, 0x31, 0xAD, 0xF7, 0xE5, 0xAD, 0x98, 0x14, 0xDF, 0x19, 0xF0, 0xC9, 0xBE, 0x37, 0xF6, 0xF0, 0x23, 0x66, 0xCF, 0x34, 0xE3, 0xD5, 0x8F, 0xD4, 0x07, 0xBA, 0x06, 0x56, 0x00, 0x66, 0x9A, 0xEB, 0x93
};
static const unsigned char App_sdk2_HdrPrivK[0x100] =
{
0xBC, 0x49, 0x29, 0xB9, 0x01, 0x52, 0x31, 0x76, 0x4C, 0xBA, 0xB1, 0x29, 0x91, 0x77, 0x29, 0xF2, 0x54, 0xE4, 0x6C, 0xB5, 0x68, 0xE1, 0xF0, 0x28, 0xDB, 0x8E, 0x54, 0xA8, 0xB1, 0xA3, 0xBE, 0x3F, 0xCA, 0xCA, 0x95, 0x9D, 0x4E, 0x12, 0xD7, 0x77, 0x6F, 0xB0, 0x9D, 0x85, 0x91, 0x5D, 0x29, 0x3A, 0x54, 0x3A, 0xD6, 0xEE, 0x11, 0xE5, 0xDF, 0xEF, 0xEA, 0x45, 0xD3, 0xFE, 0x58, 0x03, 0x7B, 0xE4, 0x7B, 0x19, 0x75, 0x02, 0xFE, 0xDE, 0xFF, 0x8C, 0x28, 0x33, 0xFE, 0x10, 0x11, 0xD4, 0xCD, 0x13, 0x05, 0x26, 0x85, 0xC3, 0xA8, 0x8A, 0x7A, 0x8A, 0x77, 0x1D, 0x49, 0x25, 0x11, 0x34, 0xB0, 0xBF, 0x45, 0x56, 0xCE, 0x42, 0x2E, 0x1B, 0x5C, 0xC4, 0xDD, 0x71, 0xA0, 0x01, 0x50, 0x73, 0x21, 0xFF, 0x5D, 0x54, 0x6D, 0xDD, 0x3F, 0x14, 0x49, 0x4D, 0x44, 0x46, 0x12, 0x88, 0xD5, 0x92, 0xAE, 0xE2, 0xD0, 0xF6, 0x2C, 0x10, 0xD5, 0x67, 0x61, 0x87, 0x7F, 0x2A, 0x17, 0x9D, 0x4F, 0xC6, 0x79, 0xC3, 0xAF, 0x4D, 0x6F, 0xFB, 0x0F, 0x3B, 0x48, 0x5D, 0x46, 0x9A, 0xE8, 0x53, 0xB7, 0xC5, 0x69, 0xEC, 0x31, 0x25, 0xD1, 0xDC, 0x93, 0xAB, 0x2E, 0x53, 0x3B, 0x8E, 0x96, 0x27, 0x59, 0xD4, 0xF7, 0xB3, 0xAB, 0x51, 0x59, 0xAE, 0x6E, 0x26, 0x4F, 0xC2, 0x95, 0xCE, 0x42, 0xC6, 0xAF, 0x46, 0xC6, 0x2E, 0x32, 0x09, 0x7B, 0xAF, 0x67, 0x4E, 0x57, 0xC8, 0x93, 0x5F, 0x8C, 0xD5, 0x66, 0x7B, 0xCC, 0xE9, 0xBE, 0x86, 0xB9, 0xBB, 0xD0, 0xC8, 0xD2, 0xDC, 0x5F, 0x95, 0x83, 0x28, 0x55, 0x21, 0x1E, 0xEE, 0xCF, 0x23, 0xB7, 0x6D, 0xE0, 0x9A, 0x87, 0x99, 0xFB, 0x82, 0x50, 0xD0, 0x2D, 0xC4, 0xFB, 0xA0, 0x11, 0x2F, 0xDD, 0x05, 0x7E, 0x1C, 0xE3, 0xFB, 0x98, 0x69, 0xD4, 0x49, 0x2F, 0x0D, 0xF6, 0x61
};
static const unsigned char App_sdk2_AcexData[0x200] =
{
0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFB, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0x1D, 0x02, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char App_sdk2_AcexSig[0x100] =
{
0x62, 0xFE, 0xD9, 0x12, 0x3D, 0x99, 0x53, 0xC4, 0x20, 0x25, 0xDE, 0x59, 0xEA, 0x6E, 0xF3, 0x16, 0x5B, 0x36, 0xBA, 0x1C, 0xB3, 0xB5, 0x48, 0x37, 0xD2, 0xA4, 0x04, 0xE5, 0x14, 0xC6, 0xE7, 0x22, 0x14, 0x40, 0x6F, 0x92, 0x6A, 0x9B, 0xDF, 0xDE, 0xFA, 0xCE, 0x3C, 0xBB, 0x4B, 0xC4, 0x66, 0xA8, 0x86, 0x58, 0xAC, 0xEB, 0x2F, 0xB7, 0xA3, 0xEC, 0xEA, 0x31, 0x23, 0x61, 0xF6, 0x72, 0x1E, 0x26, 0x8A, 0x1D, 0x68, 0x2A, 0x2A, 0x21, 0x5A, 0xA2, 0x6A, 0xBD, 0xCE, 0xC0, 0x19, 0x08, 0x61, 0x64, 0xB3, 0xF6, 0x90, 0xB1, 0x34, 0xF8, 0x50, 0x6F, 0x83, 0xB6, 0x8D, 0x35, 0x12, 0x7F, 0x9C, 0x7B, 0x6E, 0x3C, 0x4E, 0xD1, 0xFD, 0xC3, 0x30, 0xD2, 0xE8, 0x7E, 0x15, 0x1F, 0xAD, 0xDB, 0x1D, 0x92, 0xDA, 0x8C, 0x4E, 0xE9, 0x84, 0x83, 0xFF, 0x1A, 0x09, 0x77, 0x05, 0x5A, 0xCF, 0x5C, 0x8B, 0x4F, 0x68, 0x36, 0xC8, 0xDA, 0x5B, 0x1A, 0x5A, 0x49, 0xF9, 0xA1, 0xF2, 0xC8, 0x02, 0xFD, 0x69, 0x1F, 0x1D, 0xB3, 0xE8, 0xF8, 0xE1, 0x6B, 0x15, 0x9A, 0x5E, 0x41, 0x84, 0x06, 0x1F, 0x2A, 0xB3, 0xB2, 0xA1, 0xDC, 0x63, 0x81, 0xB3, 0x6B, 0x4B, 0x21, 0x67, 0x19, 0x82, 0x52, 0xFE, 0x75, 0x96, 0xA1, 0xDF, 0x02, 0xD4, 0x07, 0x1F, 0x1B, 0x88, 0x12, 0x5A, 0x76, 0x54, 0xC4, 0x06, 0x2D, 0xB1, 0xAA, 0x41, 0x3C, 0x9F, 0x43, 0xA2, 0x75, 0x20, 0x39, 0xB6, 0x06, 0xF9, 0x9C, 0xFC, 0x00, 0xC5, 0xBC, 0x84, 0x13, 0x80, 0xE4, 0x10, 0x1A, 0xCD, 0x95, 0xBB, 0xF2, 0xDC, 0x57, 0x7B, 0xBA, 0x87, 0x05, 0x0B, 0x96, 0xC1, 0xCD, 0x60, 0xC7, 0x10, 0x44, 0x78, 0x0E, 0x0F, 0x2F, 0x91, 0x54, 0x6C, 0xDE, 0xB8, 0x14, 0x46, 0xF3, 0x9C, 0xAC, 0x7B, 0xAA, 0xE7, 0x1B, 0x52, 0xD6, 0xBE, 0x71, 0x97, 0x22
};
// DLP
static const unsigned char Dlp_sdk2_HdrPubK[0x100] =
{
0xB9, 0xDE, 0x3D, 0xC0, 0x55, 0xB9, 0xCC, 0x3F, 0x55, 0xE0, 0x61, 0x1D, 0x6F, 0xCF, 0x3E, 0x7F, 0xE2, 0xF7, 0xF5, 0xAD, 0x5C, 0x02, 0x7F, 0x17, 0x5B, 0x44, 0x2F, 0x2D, 0xDC, 0xD4, 0xA6, 0x63, 0xD2, 0xA7, 0x82, 0xD3, 0x00, 0x77, 0xC8, 0x0B, 0x28, 0x09, 0x3D, 0x81, 0x86, 0x93, 0xF5, 0xF6, 0xE4, 0x69, 0x3B, 0x60, 0x4C, 0x7F, 0x8D, 0x72, 0xA3, 0x22, 0x42, 0x86, 0x87, 0x06, 0xD8, 0x29, 0x89, 0x8A, 0x9F, 0x5F, 0x6C, 0x06, 0x0C, 0x96, 0x84, 0x00, 0x24, 0x5D, 0x0B, 0xEA, 0x15, 0xEC, 0xAD, 0x90, 0xA4, 0x0C, 0x7B, 0xAE, 0x0E, 0x85, 0x3E, 0xA2, 0x20, 0x04, 0xE8, 0xD9, 0x59, 0x0F, 0x31, 0x0E, 0xD4, 0x5D, 0xC1, 0x18, 0xED, 0x0E, 0xB4, 0xD2, 0x5E, 0x65, 0xA2, 0x78, 0x0C, 0x76, 0x03, 0x3A, 0x71, 0x18, 0xE4, 0x38, 0x44, 0x14, 0xE0, 0x93, 0x84, 0xFE, 0x34, 0x82, 0xCA, 0x0B, 0xB8, 0xF2, 0x41, 0xAB, 0x63, 0xF3, 0xDE, 0xAE, 0xF4, 0x36, 0x81, 0xA4, 0x78, 0x7B, 0xF9, 0xA8, 0xFB, 0xC9, 0xA7, 0x6E, 0xA4, 0xD5, 0xE2, 0xA9, 0xD8, 0xD9, 0xE8, 0x98, 0x1B, 0x25, 0x75, 0x00, 0x11, 0x51, 0x97, 0x62, 0x0D, 0xF0, 0x0C, 0xE9, 0x6B, 0x0C, 0xEE, 0xCE, 0x25, 0x2C, 0x3F, 0xDF, 0xBE, 0x54, 0xD5, 0xD6, 0x5E, 0xEE, 0x1F, 0x73, 0xFC, 0xE8, 0xEC, 0xB3, 0x8A, 0x48, 0x9F, 0x6A, 0xC1, 0x63, 0x85, 0xE4, 0x94, 0x85, 0x8F, 0x3D, 0x9D, 0x43, 0xB4, 0xA7, 0x4C, 0x82, 0xA3, 0x0B, 0x67, 0x43, 0x12, 0x31, 0x77, 0x89, 0xB0, 0xD5, 0x00, 0x1B, 0x52, 0x29, 0xCE, 0x54, 0xC7, 0xC4, 0x7D, 0xB6, 0x69, 0x7B, 0xFE, 0xDC, 0xDB, 0x4E, 0xD8, 0x58, 0x42, 0x14, 0x34, 0x72, 0x64, 0xBC, 0x09, 0x6D, 0xAC, 0xD3, 0xC4, 0x1B, 0x5C, 0x8E, 0xF9, 0xBE, 0x84, 0xCD, 0x9A, 0x86, 0x4B, 0x17
};
static const unsigned char Dlp_sdk2_HdrPrivK[0x100] =
{
0xAA, 0x51, 0x62, 0x58, 0x9A, 0xB5, 0x74, 0xDA, 0x1C, 0xC1, 0x4D, 0x7C, 0x81, 0xF6, 0x70, 0x99, 0x13, 0xCC, 0x90, 0x0D, 0xD9, 0xA0, 0x58, 0x01, 0x79, 0x1A, 0x53, 0xF9, 0x3C, 0xC0, 0x87, 0xF0, 0x35, 0x1A, 0x56, 0xA1, 0x2F, 0x6E, 0x93, 0x9A, 0xD5, 0x87, 0x12, 0x1B, 0x5C, 0xCC, 0xBC, 0xB9, 0x0E, 0xB8, 0xF7, 0x35, 0xD9, 0x23, 0x90, 0xE4, 0x19, 0x64, 0xCD, 0x7D, 0x24, 0xC2, 0x3A, 0xD6, 0x65, 0x38, 0xE7, 0xAD, 0xB2, 0xF9, 0x20, 0x13, 0xD4, 0xC5, 0xA4, 0x8C, 0xB6, 0xDC, 0x3C, 0x56, 0xF2, 0xFC, 0xF5, 0xB6, 0x92, 0xA6, 0xFE, 0x9B, 0x4E, 0xB7, 0x95, 0x8B, 0xAA, 0x2B, 0x70, 0x96, 0xA1, 0x27, 0xAB, 0xA6, 0x75, 0xC9, 0x77, 0x80, 0xE0, 0x65, 0x5D, 0x26, 0xD8, 0xE8, 0x14, 0xD3, 0x17, 0x46, 0x38, 0x58, 0xCC, 0xD8, 0x5A, 0x5A, 0x9F, 0x27, 0xCE, 0xD8, 0x7A, 0x19, 0xD7, 0x35, 0xB2, 0x32, 0xAF, 0x47, 0x2E, 0x9F, 0x4B, 0x64, 0xEC, 0x1F, 0xC6, 0x40, 0xD0, 0x2C, 0x47, 0xD1, 0xEA, 0x33, 0xE5, 0x0E, 0x80, 0xFC, 0x68, 0xEC, 0x8C, 0x12, 0x33, 0xCE, 0x34, 0x28, 0x79, 0xFA, 0x05, 0x5D, 0x70, 0x15, 0xDE, 0xB1, 0x22, 0x85, 0x18, 0x63, 0x15, 0x35, 0x57, 0x04, 0x17, 0x64, 0x20, 0xC8, 0x52, 0x44, 0x64, 0x5E, 0x47, 0x4E, 0x5F, 0x80, 0x21, 0x16, 0x94, 0x4B, 0x18, 0x11, 0x36, 0x67, 0x3B, 0x6C, 0x69, 0x19, 0xCF, 0xC9, 0x05, 0x85, 0x9B, 0x3A, 0xDE, 0x12, 0x1E, 0x0A, 0xC6, 0x22, 0xA8, 0xC7, 0x9A, 0x34, 0x14, 0x98, 0xFD, 0xD9, 0x0F, 0xE8, 0x64, 0xE6, 0x89, 0x63, 0x6E, 0x17, 0x76, 0xD7, 0x1B, 0x6F, 0x92, 0x00, 0xD8, 0xBB, 0xF6, 0xA0, 0x65, 0x9D, 0xAA, 0x7A, 0x0E, 0x4B, 0x56, 0xA5, 0x33, 0xDA, 0x3F, 0x5D, 0xFE, 0xD3, 0xAD, 0x6E, 0x0E, 0xB3, 0xD4, 0x41
};
static const unsigned char Dlp_sdk2_AcexData[0x200] =
{
0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFB, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0x1D, 0x02, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char Dlp_sdk2_AcexSig[0x100] =
{
0x97, 0x84, 0x97, 0xEE, 0x4F, 0x35, 0xCC, 0xBE, 0x08, 0xB4, 0x5D, 0x7E, 0x17, 0xC3, 0x94, 0x2B, 0x4D, 0x3A, 0xA5, 0xB5, 0x01, 0xD4, 0xAE, 0x2A, 0x90, 0x26, 0x21, 0x8F, 0x56, 0x05, 0xB9, 0xA2, 0x5E, 0xCE, 0x73, 0xC7, 0x42, 0xDC, 0x99, 0xD2, 0x7C, 0x08, 0x62, 0xBF, 0x10, 0x7A, 0xC1, 0x5D, 0x22, 0x53, 0x8F, 0x63, 0x2D, 0x73, 0xF3, 0x05, 0xDA, 0x9D, 0x6A, 0xF8, 0xB9, 0x5B, 0x80, 0xB4, 0x30, 0xB3, 0x11, 0xF7, 0x96, 0x8A, 0xCF, 0x70, 0xD7, 0x62, 0x6E, 0x99, 0x32, 0xFD, 0x74, 0x34, 0x16, 0xFD, 0x17, 0x1F, 0xB1, 0xEC, 0xA4, 0x0F, 0x52, 0x13, 0x9F, 0x62, 0x0D, 0xE0, 0x50, 0xA6, 0xA0, 0x7B, 0x69, 0x95, 0xE0, 0xE9, 0xBB, 0x38, 0x0C, 0x62, 0xE0, 0xE3, 0xCE, 0x82, 0xE0, 0xB9, 0xE0, 0xF6, 0x61, 0x50, 0xBF, 0xA8, 0x18, 0x15, 0x38, 0xFE, 0xFA, 0x8C, 0xBA, 0xA5, 0xB9, 0x9C, 0x05, 0xA6, 0x91, 0x5C, 0xA7, 0x13, 0x6F, 0x13, 0x3F, 0xF1, 0xF6, 0x68, 0xAF, 0x40, 0xEC, 0x27, 0xE0, 0x33, 0x6B, 0xCF, 0x26, 0x06, 0xF8, 0x6A, 0x13, 0x6C, 0xBC, 0xDB, 0xAF, 0x6F, 0x78, 0xA0, 0x80, 0x10, 0x8F, 0xB6, 0x91, 0x5A, 0x43, 0x2C, 0x5F, 0x1D, 0xBA, 0xB4, 0x5E, 0xBE, 0xAE, 0x53, 0x09, 0x17, 0x5B, 0x6C, 0xC1, 0x5E, 0x0F, 0x72, 0x6E, 0xD6, 0x10, 0x0B, 0xC3, 0x26, 0xDC, 0xAF, 0xCA, 0x28, 0xAB, 0x00, 0x67, 0x04, 0xE3, 0x54, 0xE8, 0x95, 0xC6, 0x23, 0xB6, 0x79, 0x70, 0xA4, 0x87, 0x6D, 0x12, 0x48, 0xCC, 0x11, 0x86, 0xEC, 0x82, 0xF4, 0x30, 0xC9, 0xB1, 0x6D, 0x08, 0xA7, 0xEA, 0x8C, 0x6A, 0x97, 0xAA, 0x89, 0xD5, 0xC5, 0x07, 0xA9, 0xD5, 0xCF, 0x09, 0x08, 0xBC, 0x56, 0x63, 0x8D, 0x70, 0x2F, 0x64, 0xAF, 0x51, 0x9E, 0x22, 0xA4, 0x88, 0xF0, 0xDC, 0x56, 0x72, 0x28
};
/* CTR_SDK 4/5 (4.2.8) */
// DependencyList
static const unsigned char sdk4_dep_list[0x180] =
{
0x02, 0x24, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x15, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x34, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x16, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x26, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x17, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x18, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x27, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x28, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1A, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x32, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x29, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x33, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x20, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x35, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x21, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x31, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x22, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x37, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x23, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// APP
static const unsigned char App_sdk4_HdrPubK[0x100] =
{
0xCF, 0xEC, 0xB2, 0x48, 0x03, 0x6D, 0xB8, 0x09, 0xE3, 0x5C, 0x6C, 0x62, 0x2C, 0xA9, 0x49, 0xE1, 0xF4, 0xF4, 0x0C, 0x6C, 0xC3, 0xE5, 0x2F, 0x9D, 0x50, 0xA0, 0x2B, 0x5A, 0x00, 0xC6, 0x72, 0x00, 0x0B, 0xA3, 0x04, 0x5D, 0x94, 0x46, 0xE7, 0x00, 0x1B, 0x48, 0x85, 0xB5, 0x61, 0x2C, 0xC9, 0x74, 0xCA, 0x2B, 0x43, 0x13, 0xC1, 0x78, 0x97, 0x5C, 0x33, 0x2F, 0x07, 0xC7, 0x85, 0xF0, 0xDA, 0xDB, 0x60, 0x96, 0x50, 0x0F, 0x7C, 0x4B, 0x7A, 0xD7, 0x17, 0x9D, 0xE4, 0xE5, 0xC3, 0xAB, 0x6F, 0x5D, 0xA5, 0x78, 0x32, 0xAD, 0x04, 0xDD, 0x96, 0x6E, 0xDC, 0x75, 0xFF, 0xC2, 0x2F, 0xFA, 0xA2, 0xEE, 0x46, 0x89, 0xCD, 0xAE, 0x69, 0x92, 0xA4, 0x48, 0xBC, 0x46, 0x47, 0xC4, 0x8C, 0x89, 0x63, 0xE1, 0x0A, 0x4D, 0x1C, 0xDC, 0x46, 0x2F, 0x5B, 0x70, 0x8A, 0x7C, 0xE9, 0x22, 0x9C, 0x09, 0x0B, 0xA8, 0x97, 0x40, 0xCA, 0x2A, 0x7D, 0x84, 0xA1, 0x04, 0x4A, 0x2E, 0xDB, 0xD7, 0xD0, 0x64, 0x43, 0x9C, 0xD0, 0x78, 0x11, 0x41, 0x88, 0x33, 0xDD, 0x31, 0x62, 0x90, 0x2D, 0x17, 0xF2, 0xC6, 0xA9, 0x2B, 0x9C, 0x70, 0xAB, 0xDC, 0xD3, 0xAB, 0x5D, 0xDA, 0xEE, 0x3D, 0x6C, 0x0E, 0x81, 0xFF, 0xF6, 0x67, 0x5A, 0x44, 0xF9, 0xAC, 0x07, 0x3D, 0x23, 0x94, 0x75, 0x65, 0x93, 0x20, 0x0C, 0xC5, 0x76, 0x1D, 0x0F, 0x65, 0x06, 0x3D, 0x21, 0xA2, 0xF0, 0x96, 0x80, 0xB7, 0x0A, 0x49, 0x53, 0x38, 0xA3, 0x5D, 0xC0, 0x74, 0x3C, 0xA4, 0xD9, 0x40, 0x36, 0x85, 0x1F, 0x8C, 0xD1, 0x2D, 0x15, 0xF9, 0xEF, 0x24, 0xA9, 0x7E, 0x9D, 0xB2, 0x1E, 0xF8, 0xA0, 0x72, 0x81, 0x17, 0x77, 0x73, 0xB1, 0x56, 0x7F, 0xAD, 0x05, 0xA2, 0xD2, 0x30, 0x5A, 0xF5, 0xD3, 0xAF, 0x0F, 0x10, 0x4A, 0x52, 0xD8, 0x09, 0x47, 0x97
};
static const unsigned char App_sdk4_HdrPrivK[0x100] =
{
0x8C, 0xBD, 0xB2, 0x3B, 0xCE, 0x9E, 0x51, 0x09, 0xD8, 0x6D, 0x72, 0x2B, 0xCE, 0x01, 0x55, 0x32, 0x6E, 0xC5, 0x57, 0x37, 0xB4, 0x2E, 0x09, 0x59, 0xD9, 0xFE, 0x60, 0xF9, 0xCE, 0x36, 0x85, 0x6A, 0x04, 0x76, 0x76, 0xF9, 0x04, 0xEA, 0x2D, 0x68, 0xC4, 0x0F, 0x05, 0xFA, 0xAD, 0x69, 0x4C, 0x80, 0x12, 0x6C, 0xD0, 0x3D, 0xAA, 0x22, 0xFF, 0x89, 0x78, 0x57, 0xE8, 0x53, 0x25, 0x15, 0xD0, 0x7E, 0xD8, 0x55, 0x46, 0xA2, 0x04, 0xC7, 0x6E, 0xC1, 0xF3, 0x89, 0x7C, 0x2C, 0x0E, 0x93, 0x97, 0x91, 0x72, 0xF4, 0xF6, 0x90, 0x69, 0x0F, 0xB8, 0xC9, 0x17, 0xCF, 0x83, 0xAC, 0xA5, 0x1F, 0x69, 0x74, 0x12, 0x29, 0x2B, 0x21, 0x58, 0xF2, 0xDA, 0xE3, 0x25, 0x16, 0x09, 0x74, 0x40, 0x90, 0xAB, 0x1B, 0xE4, 0x06, 0x28, 0x77, 0xED, 0xC6, 0x16, 0x86, 0x0A, 0x27, 0xDD, 0x03, 0x01, 0x4D, 0x9A, 0x26, 0x6E, 0xC8, 0x9F, 0xD3, 0x9A, 0x4B, 0x59, 0xD1, 0x10, 0x9B, 0xEB, 0xA9, 0x58, 0x72, 0xBD, 0xA1, 0xFE, 0x9D, 0x86, 0xED, 0x29, 0xE9, 0x29, 0x49, 0x62, 0x4B, 0xD8, 0x7D, 0x2A, 0x7A, 0x66, 0x1B, 0xE5, 0x04, 0x81, 0x56, 0x10, 0x50, 0xAF, 0xB8, 0x48, 0x27, 0xC1, 0xC9, 0x46, 0xBD, 0x3F, 0x16, 0x06, 0xA5, 0x3D, 0x04, 0x9F, 0x0D, 0x54, 0x71, 0x1C, 0xF4, 0x82, 0xC0, 0x66, 0x74, 0xEA, 0x9C, 0x83, 0x3C, 0x27, 0x01, 0xDF, 0x6F, 0x56, 0xA8, 0x1B, 0xE3, 0x68, 0x55, 0x9F, 0xAB, 0x90, 0x67, 0x20, 0x25, 0xFA, 0x3D, 0x51, 0x2A, 0x23, 0x16, 0xCB, 0x06, 0x5A, 0xAD, 0xAC, 0xC8, 0x47, 0xF9, 0x39, 0x2E, 0x6A, 0xF8, 0xFA, 0x0A, 0xE8, 0x8A, 0x64, 0x84, 0x6B, 0xED, 0xDA, 0x8F, 0x2A, 0x08, 0x86, 0x8F, 0x56, 0x69, 0x64, 0xC3, 0x98, 0x55, 0x37, 0x9A, 0x48, 0x40, 0xDA, 0xD5, 0x03, 0x21
};
static const unsigned char App_sdk4_AcexData[0x200] =
{
0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x9E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0x21, 0x02, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char App_sdk4_AcexSig[0x100] =
{
0xDF, 0x1C, 0x8B, 0x98, 0xE4, 0x6F, 0xA2, 0x35, 0x6C, 0xC3, 0x18, 0x17, 0x98, 0xF3, 0xCE, 0x54, 0x7E, 0x14, 0x2E, 0x7F, 0x1E, 0xD8, 0x6D, 0xCF, 0xBC, 0x29, 0x4E, 0xFE, 0x32, 0x2E, 0xC1, 0x11, 0xAD, 0x46, 0x9A, 0xC6, 0x70, 0xEA, 0xEE, 0x28, 0x55, 0x22, 0xE1, 0x36, 0x05, 0x1C, 0x04, 0x8A, 0xCE, 0x0F, 0x0C, 0x83, 0x8F, 0xC8, 0xD6, 0xDE, 0x11, 0x8E, 0xEA, 0xCF, 0xAD, 0x9B, 0xCF, 0x81, 0x0D, 0xEB, 0x71, 0x13, 0xB3, 0xD3, 0xAE, 0x83, 0x02, 0x4C, 0x0E, 0x10, 0x50, 0x59, 0x3C, 0xEE, 0x60, 0x06, 0xFB, 0x8C, 0x7F, 0xC2, 0x20, 0x24, 0x01, 0x62, 0x55, 0x87, 0x60, 0x0F, 0xAD, 0xFA, 0x73, 0x2E, 0xF6, 0x65, 0x62, 0xD2, 0xE5, 0x10, 0x45, 0x69, 0x70, 0x39, 0x03, 0xD1, 0x39, 0xEC, 0x50, 0xC1, 0xD4, 0x25, 0x39, 0xB2, 0x90, 0x11, 0x4E, 0x95, 0xCB, 0x19, 0xEB, 0xCA, 0x0F, 0xB5, 0xFA, 0xC7, 0xB0, 0xE2, 0xD7, 0xE0, 0x71, 0xC3, 0xE5, 0x55, 0x33, 0x9E, 0x5C, 0xDC, 0x4D, 0x3B, 0x51, 0x11, 0x0D, 0x31, 0x78, 0x96, 0xCA, 0xD7, 0x18, 0x58, 0xEE, 0x00, 0xE9, 0x28, 0xF2, 0x68, 0x76, 0xD4, 0x57, 0xFE, 0x65, 0xB1, 0x4B, 0x49, 0x3F, 0xF6, 0xA6, 0x58, 0x4A, 0xC7, 0xFC, 0xC4, 0xBB, 0x61, 0xBC, 0x58, 0x8D, 0x55, 0x65, 0xE6, 0x0A, 0x79, 0x39, 0x41, 0xB8, 0x80, 0x61, 0xF7, 0x05, 0xC3, 0xFE, 0xD6, 0x8B, 0x09, 0x82, 0xC2, 0x5F, 0xA6, 0x56, 0xF9, 0xEE, 0x1D, 0x0E, 0x06, 0x3E, 0x9F, 0x3F, 0xF1, 0x93, 0x9A, 0x4F, 0xA2, 0xD5, 0x91, 0x87, 0x8A, 0xFE, 0xCF, 0xC3, 0xFC, 0x8A, 0xB1, 0xC4, 0x78, 0xE9, 0xD1, 0x1A, 0xF7, 0xB1, 0xD3, 0x20, 0xCB, 0x83, 0xBE, 0x03, 0xD5, 0xCA, 0xA5, 0x5E, 0x17, 0xA6, 0x91, 0x10, 0xD4, 0xBE, 0x23, 0xD6, 0x4B, 0x4F, 0x03, 0xA9, 0xAE
};
// DEMO
static const unsigned char Demo_sdk4_HdrPubK[0x100] =
{
0xB5, 0x11, 0x8D, 0x9E, 0x2D, 0xDB, 0x70, 0x6D, 0x6E, 0xEE, 0xAA, 0x21, 0xE0, 0x4E, 0x80, 0x0A, 0x96, 0x4A, 0x10, 0xD0, 0x9C, 0xD7, 0xD9, 0xD4, 0x94, 0x87, 0x72, 0xA2, 0xAF, 0x02, 0xA0, 0x05, 0x2E, 0xBF, 0x17, 0xEB, 0xFE, 0x5B, 0x9F, 0xB7, 0x0B, 0x1E, 0x3E, 0xF9, 0xAC, 0xBC, 0x7B, 0xB1, 0x56, 0x10, 0x24, 0x5F, 0x57, 0x2C, 0x08, 0xD0, 0x14, 0x79, 0x83, 0x84, 0x6A, 0x45, 0x25, 0xEB, 0xD9, 0xBE, 0x02, 0x21, 0xF7, 0x35, 0xC2, 0x74, 0x57, 0xC5, 0xAC, 0x34, 0x05, 0xC6, 0x9E, 0x82, 0xB8, 0xED, 0x78, 0xC4, 0x3B, 0xFD, 0x23, 0x59, 0x54, 0xD2, 0x0A, 0x0B, 0x5B, 0x25, 0xC0, 0x71, 0xC3, 0x84, 0x3A, 0xA7, 0xF9, 0x99, 0x86, 0xD8, 0xFE, 0x60, 0x10, 0x85, 0x77, 0x57, 0x76, 0x0C, 0x25, 0xE1, 0x18, 0x18, 0x3B, 0x83, 0xFD, 0x36, 0x7C, 0x84, 0x58, 0xC2, 0xC4, 0x68, 0x4F, 0xD1, 0xD7, 0x0A, 0x88, 0xFD, 0xCA, 0x97, 0xA1, 0xE5, 0xCE, 0x72, 0x63, 0xCF, 0x74, 0xD0, 0x20, 0xD9, 0xDE, 0x3F, 0xBB, 0x11, 0xF9, 0x21, 0xAB, 0x3F, 0x54, 0x41, 0xA7, 0xAA, 0xCA, 0xFC, 0xE1, 0x1A, 0x8C, 0x12, 0xC9, 0x39, 0x13, 0x5A, 0x81, 0x29, 0x49, 0xE8, 0xFB, 0x48, 0xC9, 0x4D, 0x50, 0x87, 0xAE, 0x51, 0xFB, 0x94, 0xFC, 0xF0, 0x9C, 0x70, 0x1C, 0xE8, 0x6E, 0x44, 0x53, 0x1E, 0x2F, 0x27, 0x5C, 0xB8, 0xEC, 0xBE, 0xFC, 0xD9, 0x98, 0x6A, 0x08, 0xD0, 0x5C, 0x4D, 0x78, 0x2D, 0x4D, 0x07, 0xAD, 0x5E, 0xB8, 0x51, 0x40, 0xE2, 0x2A, 0x7F, 0xB1, 0x54, 0x47, 0x5C, 0x99, 0x12, 0xC2, 0x6D, 0x5E, 0xED, 0x25, 0x30, 0x6A, 0x99, 0xC5, 0x0D, 0x65, 0x83, 0x68, 0x3A, 0xFD, 0x82, 0x59, 0x0D, 0xCE, 0x0B, 0x49, 0xBE, 0x17, 0x46, 0x51, 0xA9, 0xB6, 0x54, 0xE1, 0x18, 0xBD, 0x49, 0xE6, 0x7F
};
static const unsigned char Demo_sdk4_HdrPrivK[0x100] =
{
0x1D, 0x7B, 0x79, 0x32, 0xAB, 0x46, 0xD2, 0xBC, 0x8E, 0xD6, 0x7F, 0x8F, 0x3A, 0x85, 0xAD, 0xA5, 0x8B, 0xA9, 0x0D, 0xA9, 0xDA, 0x0F, 0xEF, 0x61, 0x04, 0xBA, 0x35, 0x39, 0x36, 0x03, 0xD8, 0x68, 0x5F, 0x9F, 0x2F, 0xD6, 0xF6, 0x38, 0x96, 0xFD, 0xE7, 0xEA, 0x89, 0xD8, 0x7F, 0x7E, 0xC5, 0x29, 0x2F, 0xD9, 0x3B, 0x02, 0xE7, 0x1F, 0xBD, 0x63, 0x9C, 0x21, 0xD8, 0xFF, 0x43, 0x8A, 0x74, 0xCD, 0x3D, 0x4C, 0x09, 0xEE, 0xDB, 0xE0, 0xBE, 0x03, 0xD1, 0x92, 0xD7, 0x22, 0x35, 0x5A, 0x8C, 0xCE, 0xBE, 0x2B, 0xB4, 0x81, 0x47, 0x3F, 0x45, 0x75, 0x33, 0x31, 0x6B, 0xFF, 0x43, 0x5D, 0x17, 0x43, 0xAE, 0xD1, 0x25, 0xF7, 0xD9, 0xD5, 0x5C, 0xB6, 0x92, 0x5C, 0xB3, 0xF3, 0xF7, 0x65, 0x9F, 0x4C, 0x05, 0x12, 0xEC, 0xA8, 0x6D, 0x70, 0x65, 0x57, 0x6C, 0xD8, 0xE3, 0xD6, 0xFA, 0xC1, 0xFD, 0x54, 0xE8, 0x34, 0x67, 0x4D, 0x0A, 0x14, 0x2F, 0xA3, 0xD4, 0x81, 0x8C, 0xC3, 0xD0, 0x8B, 0x09, 0x08, 0x90, 0x70, 0x68, 0xA0, 0x0E, 0xD1, 0x0B, 0xAA, 0x71, 0xEC, 0x9A, 0x1A, 0x83, 0xFF, 0xA1, 0x70, 0xEB, 0xAC, 0xF2, 0xE9, 0x80, 0xA1, 0xB8, 0x20, 0x31, 0x83, 0xF5, 0x37, 0x01, 0x72, 0x06, 0x50, 0x05, 0x3F, 0x14, 0xF9, 0x29, 0x48, 0x84, 0xA0, 0x0E, 0xF7, 0xB8, 0x1D, 0xA3, 0x36, 0x5A, 0x78, 0x6D, 0x83, 0x90, 0x27, 0xE3, 0x50, 0x49, 0x2F, 0x65, 0xE5, 0x61, 0xED, 0x65, 0xBE, 0xEA, 0x34, 0xA6, 0x6A, 0xEF, 0x49, 0xB4, 0xE0, 0xBC, 0xC2, 0xA5, 0xB8, 0xEB, 0xA9, 0x2F, 0xBA, 0x26, 0x76, 0xB2, 0x5A, 0x3A, 0x3B, 0xFD, 0xAD, 0xFB, 0xE4, 0x79, 0xE2, 0x85, 0x54, 0x5B, 0xAB, 0x1F, 0x0A, 0xE5, 0x8B, 0x77, 0x3A, 0x10, 0x98, 0x26, 0x74, 0xC8, 0xB0, 0x82, 0xB1, 0xF9, 0x8F, 0x68, 0x59
};
static const unsigned char Demo_sdk4_AcexData[0x200] =
{
0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x9E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0x21, 0x02, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char Demo_sdk4_AcexSig[0x100] =
{
0xD3, 0x7D, 0x42, 0xBA, 0x6A, 0x1E, 0xD8, 0x07, 0x3C, 0x4A, 0xC4, 0xCD, 0x8C, 0x68, 0x3D, 0xCD, 0xCD, 0xBD, 0x9D, 0xCE, 0xB5, 0x2A, 0xF9, 0x63, 0x3D, 0xA9, 0x54, 0x0A, 0x2E, 0x4C, 0xE1, 0x60, 0x4B, 0xD0, 0xC9, 0xEB, 0xEF, 0x31, 0x65, 0x70, 0xB9, 0x0E, 0x06, 0x3B, 0x3D, 0x42, 0x4C, 0x6E, 0x8D, 0x2C, 0xD4, 0x71, 0x29, 0x76, 0xB7, 0xDD, 0x8C, 0xDA, 0xE7, 0xE3, 0x96, 0xA7, 0xAA, 0xF8, 0xCA, 0x05, 0xE8, 0xA7, 0x0A, 0xDD, 0x01, 0x49, 0xBD, 0xF1, 0xA5, 0xE8, 0x16, 0x22, 0xEE, 0x47, 0x1F, 0xEF, 0x28, 0x48, 0x87, 0xA9, 0x2D, 0xFC, 0x4E, 0xD5, 0xA5, 0x98, 0xB1, 0xFE, 0x1B, 0xEB, 0xA9, 0x06, 0x3C, 0x76, 0xD9, 0xAA, 0x0E, 0x9C, 0x60, 0xFC, 0xE9, 0x77, 0x9D, 0x7F, 0x67, 0xAC, 0xF5, 0xC7, 0x49, 0x12, 0xFD, 0x76, 0xAC, 0xD2, 0x54, 0xDB, 0x73, 0x41, 0x10, 0x1F, 0x04, 0x3F, 0xD0, 0x6F, 0xE0, 0x80, 0x24, 0xCC, 0xEE, 0xBF, 0x25, 0x9D, 0x0D, 0x5A, 0x2A, 0x1C, 0xC5, 0xD4, 0xE3, 0x5D, 0x3A, 0xC1, 0x86, 0xD3, 0xD4, 0x52, 0x1C, 0x4C, 0xBF, 0x31, 0xEB, 0x54, 0xCA, 0x4C, 0x06, 0x50, 0x52, 0x87, 0xD4, 0x9D, 0x4A, 0x4B, 0x22, 0xE1, 0x4A, 0xE9, 0x4D, 0x05, 0xA8, 0x57, 0xEC, 0xF8, 0x90, 0xF8, 0x58, 0xC3, 0x8B, 0x3A, 0x0F, 0x88, 0x36, 0xF4, 0xE5, 0x44, 0x10, 0x80, 0x68, 0x86, 0x1D, 0xAE, 0x90, 0x20, 0x03, 0x22, 0x2D, 0x44, 0xBF, 0xAB, 0x2B, 0xA1, 0x14, 0xAD, 0x6B, 0x40, 0x57, 0xDB, 0xBB, 0xDA, 0x09, 0x4C, 0x51, 0x26, 0x9B, 0xE3, 0xD9, 0xF9, 0xE1, 0xBC, 0xF1, 0xF1, 0xCD, 0x30, 0xB4, 0xF5, 0x39, 0xD0, 0xBC, 0xF7, 0x98, 0x05, 0xAF, 0xA8, 0x33, 0x4B, 0xC1, 0x16, 0x0F, 0xF2, 0xC2, 0x79, 0x96, 0xEC, 0xBE, 0xA9, 0xF5, 0x55, 0x7C, 0x82, 0x95, 0x73
};
// DLP
static const unsigned char Dlp_sdk4_HdrPubK[0x100] =
{
0xB3, 0x16, 0x68, 0xF1, 0xED, 0x59, 0xC8, 0x7F, 0xC6, 0x50, 0x21, 0xFE, 0x36, 0x7C, 0x55, 0xE7, 0x07, 0xF9, 0x1D, 0x1B, 0xF5, 0xB1, 0x2A, 0x6B, 0x3A, 0xDE, 0x2D, 0x4C, 0x51, 0xCD, 0x4C, 0x9F, 0xEE, 0x1D, 0xE4, 0xE8, 0xF0, 0xFD, 0x09, 0x8E, 0x0F, 0x92, 0x5F, 0xDB, 0x9C, 0x5C, 0x15, 0x55, 0x1A, 0x4D, 0x04, 0x8C, 0xB0, 0xA4, 0x88, 0x97, 0xC4, 0xD5, 0x92, 0x04, 0x42, 0x33, 0x84, 0x81, 0x06, 0xD6, 0xF2, 0x17, 0xDE, 0x83, 0x17, 0x50, 0xD0, 0x47, 0x61, 0x14, 0x0D, 0xB7, 0xC7, 0xA0, 0xC1, 0x8B, 0x82, 0x47, 0x13, 0xEE, 0x76, 0xA2, 0xA3, 0x8D, 0xCE, 0x55, 0xC1, 0xF3, 0x7A, 0xEA, 0x91, 0xE1, 0xB9, 0x2F, 0x8F, 0x9B, 0xC3, 0x7B, 0x51, 0x2F, 0xE7, 0xAD, 0x93, 0x9C, 0xFD, 0xDF, 0x19, 0xC8, 0x6C, 0x24, 0xC2, 0xE2, 0x91, 0x97, 0x1F, 0xEB, 0x4B, 0xD4, 0x46, 0x6C, 0x06, 0x93, 0xAF, 0xF5, 0x5E, 0x8F, 0x77, 0x25, 0xC4, 0x28, 0xC0, 0x82, 0x4A, 0x78, 0xE9, 0x14, 0x08, 0xC3, 0xC3, 0x58, 0x24, 0x44, 0x2D, 0x2B, 0xA7, 0xEE, 0x28, 0xEF, 0x1B, 0x6D, 0xAA, 0x9C, 0xED, 0x7F, 0x35, 0xCE, 0x86, 0x5C, 0x6B, 0x8A, 0x23, 0xD3, 0x9D, 0x05, 0x8F, 0xD2, 0x41, 0x93, 0x1D, 0x1D, 0x7E, 0xB0, 0x46, 0x23, 0x63, 0x07, 0xEA, 0x5F, 0x26, 0xE3, 0x81, 0x27, 0xB3, 0x95, 0xB1, 0x93, 0x59, 0xD4, 0x1A, 0xB8, 0x73, 0xD0, 0x09, 0x95, 0x2B, 0xE8, 0x8B, 0xE2, 0x73, 0x5F, 0x34, 0xB9, 0x98, 0x82, 0xF0, 0x11, 0xC6, 0x8F, 0x12, 0x4D, 0x09, 0x57, 0x10, 0x97, 0x22, 0x0E, 0xC8, 0x7D, 0x40, 0xC1, 0x9D, 0x12, 0x1F, 0x71, 0xFE, 0x1E, 0x1A, 0x8C, 0x3F, 0x56, 0xAC, 0x43, 0xC3, 0x66, 0x0C, 0x81, 0xAE, 0xC1, 0x8F, 0x68, 0xFF, 0x87, 0x07, 0x3C, 0xCD, 0x0A, 0x23, 0xDE, 0xBA, 0x9B
};
static const unsigned char Dlp_sdk4_HdrPrivK[0x100] =
{
0x77, 0xC2, 0x7A, 0xB7, 0x9E, 0x13, 0xB6, 0x62, 0xCC, 0x09, 0x76, 0x51, 0xFB, 0xB9, 0xB5, 0xF0, 0x63, 0x82, 0x91, 0x96, 0xCA, 0xFC, 0x88, 0xF3, 0x60, 0x50, 0x87, 0x56, 0x4C, 0x35, 0xD0, 0x11, 0xFB, 0x38, 0x7E, 0x85, 0xCF, 0xF2, 0x46, 0xDB, 0x7B, 0x4A, 0x55, 0x54, 0x15, 0x01, 0xF7, 0x3A, 0x0B, 0xF6, 0x89, 0x1E, 0x54, 0x5A, 0x13, 0x05, 0xFB, 0x19, 0x1F, 0x26, 0x3D, 0xE7, 0x19, 0xAA, 0xF7, 0x19, 0xF2, 0x97, 0x47, 0xB3, 0xBE, 0x79, 0xCA, 0x6E, 0x91, 0x5A, 0xC9, 0xB9, 0xA6, 0x83, 0xB8, 0x2A, 0x45, 0x1A, 0xA7, 0x17, 0x86, 0xBA, 0x48, 0x49, 0x62, 0x3C, 0x33, 0x11, 0x51, 0x97, 0x5F, 0xAA, 0xE5, 0x1E, 0x0B, 0x19, 0x0C, 0xE6, 0x80, 0x6A, 0x5A, 0xB1, 0xD6, 0xCE, 0xDB, 0x6E, 0xC0, 0x5D, 0x29, 0x04, 0x84, 0x56, 0xE3, 0x29, 0x7E, 0xAC, 0xE8, 0xEE, 0xB1, 0x91, 0x37, 0xEB, 0x98, 0x9C, 0xBD, 0x02, 0x6A, 0x78, 0x61, 0xB0, 0x79, 0x1A, 0x9F, 0x30, 0x86, 0xF6, 0x71, 0x5A, 0x5A, 0x12, 0xA1, 0x9E, 0xA1, 0x68, 0x03, 0xE5, 0x95, 0xA8, 0x38, 0x58, 0x87, 0x08, 0x57, 0x35, 0x32, 0x47, 0x3B, 0xFC, 0x02, 0x6F, 0xCE, 0x55, 0x61, 0xA3, 0x2A, 0x6B, 0x2F, 0xF8, 0xEE, 0x8D, 0xFA, 0x43, 0x33, 0x02, 0x63, 0x47, 0x02, 0x78, 0x5A, 0x7F, 0x64, 0x07, 0x92, 0xB7, 0x7C, 0x09, 0x7C, 0xFE, 0x2D, 0x1C, 0xFC, 0x77, 0x9F, 0x19, 0x20, 0xDD, 0x6D, 0x4C, 0xFE, 0x49, 0x09, 0x47, 0xCA, 0x9B, 0x1C, 0x8C, 0x1F, 0x37, 0xAC, 0x14, 0x85, 0x56, 0xC0, 0xFD, 0xD6, 0x01, 0xB3, 0x40, 0xA3, 0x1A, 0x32, 0x78, 0xA0, 0xDD, 0x21, 0x75, 0xBF, 0x24, 0xD2, 0x93, 0x85, 0xED, 0x22, 0xAD, 0x99, 0x91, 0x87, 0x4A, 0xEC, 0xC0, 0x6C, 0x71, 0x00, 0x76, 0x08, 0x23, 0xA2, 0xF3, 0xCF, 0x61
};
static const unsigned char Dlp_sdk4_AcexData[0x200] =
{
0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18, 0x9E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x50, 0x54, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30, 0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31, 0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00, 0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00, 0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C, 0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52, 0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50, 0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75, 0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00, 0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00, 0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53, 0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00, 0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00, 0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00, 0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00, 0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1, 0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF, 0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF, 0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF, 0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF, 0x00, 0x02, 0x00, 0xFE, 0x21, 0x02, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char Dlp_sdk4_AcexSig[0x100] =
{
0xAC, 0xE2, 0xA7, 0xC3, 0x00, 0xDE, 0xE8, 0xE9, 0xE0, 0x03, 0xB3, 0x54, 0x08, 0xA8, 0xF8, 0x3A, 0x2E, 0xD8, 0x10, 0x6B, 0xEC, 0xDC, 0x4E, 0xEE, 0x62, 0x10, 0x71, 0x49, 0xD4, 0x43, 0xB1, 0x0E, 0x6B, 0x8C, 0xD7, 0x54, 0xD5, 0x62, 0x28, 0x3F, 0xAA, 0xDE, 0xA9, 0x7D, 0xED, 0x37, 0x7C, 0xE7, 0x89, 0x0B, 0x02, 0xB2, 0x72, 0x4B, 0x17, 0xDB, 0xE2, 0xD3, 0x7C, 0x94, 0x12, 0x3F, 0x2E, 0xA1, 0x08, 0x99, 0xCC, 0x7F, 0x93, 0xE6, 0x38, 0xC9, 0x37, 0x84, 0xD7, 0x11, 0x9D, 0x02, 0x4D, 0x66, 0xB4, 0x70, 0x9F, 0xD8, 0xC6, 0xDD, 0xD5, 0x13, 0x52, 0xF0, 0xA6, 0x78, 0x8C, 0x8E, 0x15, 0xA0, 0xA1, 0xF3, 0xC4, 0xC3, 0x48, 0x45, 0xA5, 0xBE, 0xC9, 0x7A, 0x8B, 0xD3, 0x95, 0xA5, 0x4C, 0xF1, 0xB3, 0x0C, 0x6C, 0x76, 0xA7, 0x57, 0xA1, 0x77, 0xDF, 0x2F, 0xC8, 0x06, 0xA6, 0x0D, 0x1A, 0x09, 0xE4, 0x38, 0x64, 0x07, 0xBE, 0x6A, 0xD2, 0xA0, 0xC0, 0xEC, 0x09, 0x64, 0x9F, 0x0D, 0x93, 0x0C, 0x89, 0xA2, 0x71, 0xD6, 0xC6, 0xC2, 0x54, 0x79, 0x2A, 0xA4, 0x31, 0x28, 0x24, 0x1A, 0xF3, 0x56, 0x78, 0x63, 0x99, 0x97, 0xA5, 0xCE, 0x8F, 0x52, 0x7A, 0x79, 0x51, 0xEE, 0x4C, 0x8B, 0x00, 0x9D, 0x5C, 0x3E, 0xD5, 0xAA, 0x24, 0x9C, 0x94, 0xC6, 0xA3, 0x99, 0x1B, 0x2D, 0xD4, 0xFF, 0xB4, 0x25, 0x73, 0x13, 0x33, 0x9F, 0x03, 0x6F, 0x1E, 0x75, 0xC4, 0x70, 0xF4, 0x07, 0x4F, 0x18, 0xFE, 0xBD, 0x8F, 0x2C, 0x9B, 0x33, 0xD4, 0x30, 0xA7, 0x18, 0x4A, 0xF1, 0xA4, 0xDD, 0x78, 0x41, 0xA0, 0xB8, 0x02, 0x8D, 0x51, 0x96, 0xBE, 0xE7, 0x17, 0x94, 0x66, 0x65, 0x27, 0xF7, 0x69, 0x48, 0x7E, 0xA9, 0x08, 0x71, 0x20, 0x76, 0xB7, 0x8E, 0xD2, 0xBF, 0x5C, 0x7E, 0x5E, 0x06, 0x45, 0xAB, 0x7E, 0x2E
};
/* SDK 7 (7.1.0) */
static const unsigned char sdk7_dep_list[0x180] =
{
0x02, 0x24, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x38, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x15, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x34, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x16, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x26, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x17, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x18, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x27, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x28, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1A, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x32, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x29, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x33, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x20, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2B, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x35, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2C, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2D, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x21, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x31, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x22, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x37, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2E, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x23, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x02, 0x2F, 0x00, 0x00, 0x30, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// APP
static const unsigned char App_sdk7_HdrPubK[0x100] =
{
0x9B, 0x3B, 0x52, 0x2D, 0x61, 0xF5, 0x0D, 0x14,
0x96, 0x09, 0x7A, 0x66, 0xC9, 0x86, 0x4C, 0x51,
0x61, 0x7D, 0xF8, 0x9B, 0xFD, 0xB0, 0x3E, 0x44,
0xC5, 0x0D, 0xC2, 0x6B, 0x6C, 0x66, 0x63, 0x3E,
0xE7, 0xC8, 0x04, 0xCB, 0x06, 0xC8, 0x35, 0xC5,
0x6D, 0xDB, 0x38, 0x36, 0xC5, 0x54, 0x32, 0xF0,
0x60, 0x11, 0x44, 0x9F, 0xD9, 0xFA, 0x6A, 0x43,
0xE1, 0x79, 0x56, 0xBF, 0xCF, 0xDD, 0xA8, 0x35,
0x15, 0x23, 0x51, 0xF9, 0x4B, 0xDA, 0x1A, 0xD9,
0x9D, 0x28, 0xF6, 0xCC, 0x1D, 0x53, 0x00, 0xC0,
0x3C, 0x13, 0x32, 0xBC, 0x7F, 0x75, 0x82, 0xCD,
0x79, 0xEF, 0x65, 0xBC, 0xCA, 0x98, 0x31, 0x0A,
0x7B, 0xEF, 0x18, 0xD8, 0xF3, 0x8D, 0x3A, 0x10,
0x22, 0xA0, 0xF2, 0x8D, 0xA5, 0xA8, 0xBE, 0xA0,
0x62, 0xEC, 0xE2, 0xC7, 0x6C, 0xCF, 0x06, 0x6B,
0xA7, 0xB5, 0xB8, 0x8C, 0xD5, 0x8E, 0xEF, 0xE3,
0x42, 0xC9, 0xAD, 0x44, 0x46, 0x3A, 0x4E, 0x77,
0x63, 0x02, 0xB4, 0x4E, 0xB4, 0x42, 0x65, 0x1D,
0x68, 0x98, 0x37, 0x7A, 0x27, 0x87, 0x31, 0xBE,
0x48, 0xFA, 0x4E, 0xD3, 0x85, 0xA6, 0xD6, 0xD2,
0x2D, 0xCD, 0x10, 0xC9, 0x13, 0x59, 0x12, 0x48,
0x14, 0x67, 0x3E, 0x40, 0xD3, 0xF8, 0x60, 0xA0,
0xBD, 0x77, 0x31, 0x76, 0x78, 0x85, 0x55, 0x53,
0x16, 0xF1, 0xB9, 0xFF, 0x7F, 0x3D, 0x9A, 0xF1,
0x33, 0x1E, 0x67, 0x8F, 0x6B, 0x4A, 0x7A, 0x79,
0x54, 0x8B, 0x43, 0xB5, 0xC2, 0xAF, 0xB8, 0x75,
0x11, 0xDE, 0x4D, 0x34, 0x6A, 0xD6, 0x5A, 0x3B,
0x48, 0x1F, 0x41, 0x9D, 0xF4, 0x58, 0x90, 0x67,
0xA8, 0x71, 0xD4, 0x09, 0x67, 0xF7, 0x55, 0xEF,
0xD3, 0x7C, 0x7D, 0x2F, 0x76, 0x84, 0x70, 0x6E,
0xAA, 0x75, 0x7D, 0xA9, 0x95, 0x42, 0xEF, 0x28,
0x29, 0x48, 0xCD, 0x79, 0xA8, 0x16, 0xB6, 0xB5
};
static const unsigned char App_sdk7_AcexData[0x200] =
{
0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x04, 0x00,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x18,
0x9E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x88, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x24, 0x68, 0x69, 0x6F, 0x46, 0x49, 0x4F, 0x00,
0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x30,
0x24, 0x68, 0x6F, 0x73, 0x74, 0x69, 0x6F, 0x31,
0x63, 0x66, 0x67, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x66, 0x73, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00,
0x67, 0x73, 0x70, 0x3A, 0x3A, 0x47, 0x70, 0x75,
0x68, 0x69, 0x64, 0x3A, 0x55, 0x53, 0x45, 0x52,
0x6E, 0x64, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x70, 0x78, 0x69, 0x3A, 0x64, 0x65, 0x76, 0x00,
0x41, 0x50, 0x54, 0x3A, 0x41, 0x00, 0x00, 0x00,
0x61, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00, 0x00,
0x61, 0x63, 0x74, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x61, 0x6D, 0x3A, 0x61, 0x70, 0x70, 0x00, 0x00,
0x62, 0x6F, 0x73, 0x73, 0x3A, 0x55, 0x00, 0x00,
0x63, 0x61, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x63, 0x65, 0x63, 0x64, 0x3A, 0x75, 0x00, 0x00,
0x64, 0x6C, 0x70, 0x3A, 0x46, 0x4B, 0x43, 0x4C,
0x64, 0x6C, 0x70, 0x3A, 0x53, 0x52, 0x56, 0x52,
0x64, 0x73, 0x70, 0x3A, 0x3A, 0x44, 0x53, 0x50,
0x66, 0x72, 0x64, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x68, 0x74, 0x74, 0x70, 0x3A, 0x43, 0x00, 0x00,
0x69, 0x72, 0x3A, 0x55, 0x53, 0x45, 0x52, 0x00,
0x6C, 0x64, 0x72, 0x3A, 0x72, 0x6F, 0x00, 0x00,
0x6D, 0x69, 0x63, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x6E, 0x65, 0x77, 0x73, 0x3A, 0x75, 0x00, 0x00,
0x6E, 0x69, 0x6D, 0x3A, 0x61, 0x6F, 0x63, 0x00,
0x6E, 0x77, 0x6D, 0x3A, 0x3A, 0x55, 0x44, 0x53,
0x70, 0x74, 0x6D, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x73, 0x6F, 0x63, 0x3A, 0x55, 0x00, 0x00, 0x00,
0x73, 0x73, 0x6C, 0x3A, 0x43, 0x00, 0x00, 0x00,
0x79, 0x32, 0x72, 0x3A, 0x75, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x4E, 0x9F, 0xFA, 0xF0, 0xFF, 0xBF, 0xFF, 0xF1,
0xE7, 0x3F, 0x00, 0xF2, 0x00, 0xF0, 0x91, 0xFF,
0x00, 0xF6, 0x91, 0xFF, 0x50, 0xFF, 0x81, 0xFF,
0x58, 0xFF, 0x81, 0xFF, 0x70, 0xFF, 0x81, 0xFF,
0x78, 0xFF, 0x81, 0xFF, 0x01, 0x01, 0x00, 0xFF,
0x00, 0x02, 0x00, 0xFE, 0x27, 0x02, 0x00, 0xFC,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
};
static const unsigned char App_sdk7_AcexSig[0x100] =
{
0x06, 0xDD, 0x68, 0x17, 0xAA, 0x40, 0x3A, 0x75,
0xD2, 0xCF, 0xA2, 0x5A, 0xC8, 0x1B, 0x74, 0x9D,
0x91, 0xCD, 0x38, 0x4E, 0xCA, 0x19, 0x60, 0x8E,
0x39, 0x71, 0x6C, 0xB9, 0xF9, 0x9F, 0x68, 0x44,
0xCF, 0x33, 0x94, 0x54, 0x72, 0xCC, 0xC6, 0x33,
0x96, 0x9F, 0x12, 0x07, 0xE9, 0x38, 0x87, 0x70,
0x11, 0x51, 0xFD, 0xBF, 0xD9, 0x2D, 0xFA, 0x3F,
0x70, 0x42, 0x75, 0x39, 0xE3, 0x97, 0x85, 0xAF,
0x7B, 0xC5, 0x87, 0x9B, 0x0B, 0xF9, 0xE4, 0x1C,
0xC5, 0x6B, 0x44, 0x2A, 0x10, 0x14, 0x86, 0xAA,
0xFE, 0x9E, 0x5B, 0x1D, 0x15, 0xBA, 0x8C, 0x34,
0xA2, 0xAF, 0x14, 0xD0, 0xD4, 0x0E, 0x7B, 0x3A,
0xD5, 0x3C, 0x53, 0xDB, 0x7C, 0xBE, 0x44, 0x58,
0x79, 0x42, 0x23, 0x3A, 0x77, 0xA3, 0x2C, 0xB9,
0xEB, 0x62, 0x19, 0x94, 0x2B, 0xA0, 0x67, 0x94,
0xC6, 0xB2, 0x90, 0xC6, 0x61, 0xFD, 0x43, 0xEC,
0xEA, 0x27, 0x7E, 0xA6, 0xB1, 0xED, 0xA9, 0x67,
0xED, 0x56, 0x91, 0x90, 0xF9, 0x32, 0x4E, 0xC3,
0x29, 0x5A, 0x84, 0x4C, 0xAB, 0x99, 0x75, 0x40,
0x8E, 0x19, 0xD9, 0x12, 0xD1, 0x06, 0x2D, 0xD0,
0x2C, 0xD9, 0x6C, 0x41, 0x35, 0x64, 0xDB, 0x80,
0x63, 0xB2, 0x01, 0xF8, 0x29, 0xAB, 0xF5, 0x70,
0x79, 0x4E, 0x0F, 0xFA, 0x23, 0x20, 0x2E, 0x04,
0x75, 0x48, 0x15, 0x9B, 0x71, 0xD5, 0x85, 0x09,
0x67, 0x7D, 0xAC, 0x6A, 0xFA, 0xC0, 0x16, 0xAF,
0x58, 0x26, 0xCD, 0x6F, 0x1F, 0xB8, 0xF5, 0x8D,
0xD1, 0x7D, 0x3D, 0x70, 0x2F, 0x08, 0xB8, 0x23,
0x61, 0x24, 0xAE, 0x94, 0x31, 0xA3, 0xBD, 0x1E,
0x18, 0xD7, 0x82, 0x92, 0xDD, 0x11, 0x79, 0x7D,
0x1F, 0xEC, 0x03, 0x08, 0x82, 0xCC, 0x52, 0x62,
0xC9, 0x27, 0x2D, 0x08, 0xD5, 0x6B, 0x4E, 0x86,
0x2E, 0x3F, 0x50, 0x5C, 0xA3, 0xC1, 0xDF, 0xF5,
};
#endif
blz.c
-336
View File
@@ -1,336 +0,0 @@
/*----------------------------------------------------------------------------*/
/*-- blz.c - Bottom LZ coding for Nintendo GBA/DS --*/
/*-- Copyright (C) 2011 CUE --*/
/*-- --*/
/*-- This program is free software: you can redistribute it and/or modify --*/
/*-- it under the terms of the GNU General Public License as published by --*/
/*-- the Free Software Foundation, either version 3 of the License, or --*/
/*-- (at your option) any later version. --*/
/*-- --*/
/*-- This program is distributed in the hope that it will be useful, --*/
/*-- but WITHOUT ANY WARRANTY; without even the implied warranty of --*/
/*-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the --*/
/*-- GNU General Public License for more details. --*/
/*-- --*/
/*-- You should have received a copy of the GNU General Public License --*/
/*-- along with this program. If not, see <http://www.gnu.org/licenses/>. --*/
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#include "lib.h"
#include "blz.h"
/*----------------------------------------------------------------------------*/
#define CMD_DECODE 0x00 // decode
#define CMD_ENCODE 0x01 // encode
#define BLZ_SHIFT 1 // bits to shift
#define BLZ_MASK 0x80 // bits to check:
// ((((1 << BLZ_SHIFT) - 1) << (8 - BLZ_SHIFT)
#define BLZ_THRESHOLD 2 // max number of bytes to not encode
#define BLZ_N 0x1002 // max offset ((1 << 12) + 2)
#define BLZ_F 0x12 // max coded ((1 << 4) + BLZ_THRESHOLD)
#define RAW_MINIM 0x00000000 // empty file, 0 bytes
#define RAW_MAXIM 0x00FFFFFF // 3-bytes length, 16MB - 1
#define BLZ_MINIM 0x00000004 // header only (empty RAW file)
#define BLZ_MAXIM 0x01400000 // 0x0120000A, padded to 20MB:
// * length, RAW_MAXIM
// * flags, (RAW_MAXIM + 7) / 8
// * header, 11
// 0x00FFFFFF + 0x00200000 + 12 + padding
/*----------------------------------------------------------------------------*/
#define BREAK(text) { printf(text); return; }
#define EXIT(text) { printf(text); exit(-1); }
/*----------------------------------------------------------------------------*/
u8 *Memory(int length, int size);
u8 *BLZ_Code(u8 *raw_buffer, int raw_len, u32 *new_len, int best);
void BLZ_Invert(u8 *buffer, int length);
/*----------------------------------------------------------------------------*/
u8 *Memory(int length, int size) {
u8 *fb;
fb = (u8 *) calloc(length * size, size);
if (fb == NULL) EXIT("\nMemory error\n");
return(fb);
}
/*----------------------------------------------------------------------------*/
void BLZ_Decode(char *filename) {
// u8 *pak_buffer, *raw_buffer, *pak, *raw, *pak_end, *raw_end;
// u32 pak_len, raw_len, len, pos, inc_len, hdr_len, enc_len, dec_len;
// u8 flags, mask;
// printf("- decoding '%s'", filename);
// // pak_buffer = Load(filename, &pak_len, BLZ_MINIM, BLZ_MAXIM);
// inc_len = *(u32 *)(pak_buffer + pak_len - 4);
// if (!inc_len) {
// enc_len = 0;
// dec_len = pak_len - 4;
// pak_len = 0;
// raw_len = dec_len;
// } else {
// if (pak_len < 8) EXIT("File has a bad header\n");
// hdr_len = pak_buffer[pak_len - 5];
// if ((hdr_len < 0x08) || (hdr_len > 0x0B)) EXIT("Bad header length\n");
// if (pak_len <= hdr_len) EXIT("Bad length\n");
// enc_len = *(u32 *)(pak_buffer + pak_len - 8) & 0x00FFFFFF;
// dec_len = pak_len - enc_len;
// pak_len = enc_len - hdr_len;
// raw_len = dec_len + enc_len + inc_len;
// if (raw_len > RAW_MAXIM) EXIT("Bad decoded length\n");
// }
// raw_buffer = (u8 *) Memory(raw_len, sizeof(char));
// pak = pak_buffer;
// raw = raw_buffer;
// pak_end = pak_buffer + dec_len + pak_len;
// raw_end = raw_buffer + raw_len;
// for (len = 0; len < dec_len; len++) *(raw++) = *(pak++);
// BLZ_Invert(pak_buffer + dec_len, pak_len);
// mask = 0;
// while (raw < raw_end) {
// if (!(mask >>= BLZ_SHIFT)) {
// if (pak == pak_end) break;
// flags = *pak++;
// mask = BLZ_MASK;
// }
// if (!(flags & mask)) {
// if (pak == pak_end) break;
// *raw++ = *pak++;
// } else {
// if (pak + 1 >= pak_end) break;
// pos = *pak++ << 8;
// pos |= *pak++;
// len = (pos >> 12) + BLZ_THRESHOLD + 1;
// if (raw + len > raw_end) {
// printf(", WARNING: wrong decoded length!");
// len = raw_end - raw;
// }
// pos = (pos & 0xFFF) + 3;
// while (len--) *(raw++) = *(raw - pos);
// }
// }
// BLZ_Invert(raw_buffer + dec_len, raw_len - dec_len);
// raw_len = raw - raw_buffer;
// if (raw != raw_end) printf(", WARNING: unexpected end of encoded file!");
// // Save(filename, raw_buffer, raw_len);
// free(raw_buffer);
// free(pak_buffer);
// printf("\n");
}
u8 *Load(char *filename, u32 *length, int min, int max) {
FILE *fp;
int fs;
u8 *fb;
if ((fp = fopen(filename, "rb")) == NULL) EXIT("\nFile open error\n");
fseek(fp, 0, SEEK_END);
fs = ftell(fp);
fseek(fp, 0, SEEK_SET);
if ((fs < min) || (fs > max)) EXIT("\nFile size error\n");
fb = Memory(fs + 3, sizeof(char));
if (fread(fb, 1, fs, fp) != fs) EXIT("\nFile read error\n");
if (fclose(fp) == EOF) EXIT("\nFile close error\n");
*length = fs;
return(fb);
}
/*----------------------------------------------------------------------------*/
u8* BLZ_Encode(char *filename, u32* pak_len, int mode) {
u8 *raw_buffer, *pak_buffer, *new_buffer;
u32 raw_len, new_len;
raw_buffer = Load(filename, &raw_len, RAW_MINIM, RAW_MAXIM);
pak_buffer = NULL;
*pak_len = BLZ_MAXIM + 1;
new_buffer = BLZ_Code(raw_buffer, raw_len, &new_len, mode);
if (new_len < *pak_len) {
if (pak_buffer != NULL) free(pak_buffer);
pak_buffer = new_buffer;
*pak_len = new_len;
}
return pak_buffer;
}
/*----------------------------------------------------------------------------*/
u8 *BLZ_Code(u8 *raw_buffer, int raw_len, u32 *new_len, int best) {
u8 *pak_buffer, *pak, *raw, *raw_end, *flg, *tmp;
u32 pak_len, inc_len, hdr_len, enc_len, len, pos, max;
u32 len_best, pos_best, len_next, pos_next, len_post, pos_post;
u32 pak_tmp, raw_tmp;
u8 mask;
#define SEARCH(l,p) { \
l = BLZ_THRESHOLD; \
\
max = raw - raw_buffer >= BLZ_N ? BLZ_N : raw - raw_buffer; \
for (pos = 3; pos <= max; pos++) { \
for (len = 0; len < BLZ_F; len++) { \
if (raw + len == raw_end) break; \
if (len >= pos) break; \
if (*(raw + len) != *(raw + len - pos)) break; \
} \
\
if (len > l) { \
p = pos; \
if ((l = len) == BLZ_F) break; \
} \
} \
}
pak_tmp = 0;
raw_tmp = raw_len;
pak_len = raw_len + ((raw_len + 7) / 8) + 11;
pak_buffer = (u8 *) Memory(pak_len, sizeof(char));
BLZ_Invert(raw_buffer, raw_len);
pak = pak_buffer;
raw = raw_buffer;
raw_end = raw_buffer + raw_len;
mask = 0;
while (raw < raw_end) {
if (!(mask >>= BLZ_SHIFT)) {
*(flg = pak++) = 0;
mask = BLZ_MASK;
}
SEARCH(len_best, pos_best);
// LZ-CUE optimization start
if (best) {
if (len_best > BLZ_THRESHOLD) {
if (raw + len_best < raw_end) {
raw += len_best;
SEARCH(len_next, pos_next);
raw -= len_best - 1;
SEARCH(len_post, pos_post);
raw--;
if (len_next <= BLZ_THRESHOLD) len_next = 1;
if (len_post <= BLZ_THRESHOLD) len_post = 1;
if (len_best + len_next <= 1 + len_post) len_best = 1;
}
}
}
// LZ-CUE optimization end
*flg <<= 1;
if (len_best > BLZ_THRESHOLD) {
raw += len_best;
*flg |= 1;
*pak++ = ((len_best - (BLZ_THRESHOLD+1)) << 4) | ((pos_best - 3) >> 8);
*pak++ = (pos_best - 3) & 0xFF;
} else {
*pak++ = *raw++;
}
if (pak - pak_buffer + raw_len - (raw - raw_buffer) < pak_tmp + raw_tmp) {
pak_tmp = pak - pak_buffer;
raw_tmp = raw_len - (raw - raw_buffer);
}
}
while (mask && (mask != 1)) {
mask >>= BLZ_SHIFT;
*flg <<= 1;
}
pak_len = pak - pak_buffer;
BLZ_Invert(raw_buffer, raw_len);
BLZ_Invert(pak_buffer, pak_len);
if (!pak_tmp || (raw_len + 4 < ((pak_tmp + raw_tmp + 3) & -4) + 8)) {
pak = pak_buffer;
raw = raw_buffer;
raw_end = raw_buffer + raw_len;
while (raw < raw_end) *pak++ = *raw++;
while ((pak - pak_buffer) & 3) *pak++ = 0;
*(u32 *)pak = 0; pak += 4;
} else {
tmp = (u8 *) Memory(raw_tmp + pak_tmp + 11, sizeof(char));
for (len = 0; len < raw_tmp; len++)
tmp[len] = raw_buffer[len];
for (len = 0; len < pak_tmp; len++)
tmp[raw_tmp + len] = pak_buffer[len + pak_len - pak_tmp];
pak = pak_buffer;
pak_buffer = tmp;
free(pak);
pak = pak_buffer + raw_tmp + pak_tmp;
enc_len = pak_tmp;
hdr_len = 8;
inc_len = raw_len - pak_tmp - raw_tmp;
while ((pak - pak_buffer) & 3) {
*pak++ = 0xFF;
hdr_len++;
}
*(u32 *)pak = enc_len + hdr_len; pak += 3;
*pak++ = hdr_len;
*(u32 *)pak = inc_len - hdr_len; pak += 4;
}
*new_len = pak - pak_buffer;
return(pak_buffer);
}
/*----------------------------------------------------------------------------*/
void BLZ_Invert(u8 *buffer, int length) {
u8 *bottom, ch;
bottom = buffer + length - 1;
while (buffer < bottom) {
ch = *buffer;
*buffer++ = *bottom;
*bottom-- = ch;
}
}
/*----------------------------------------------------------------------------*/
/*-- EOF Copyright (C) 2011 CUE --*/
/*----------------------------------------------------------------------------*/
blz.h
-9
View File
@@ -1,9 +0,0 @@
#ifndef _BLZ_H_
#define _BLZ_H_
#define BLZ_NORMAL 0 // normal mode
#define BLZ_BEST 1 // best mode
u8 *BLZ_Code(u8 *raw_buffer, int raw_len, u32 *new_len, int best);
#endif
certs.c
-139
View File
@@ -1,139 +0,0 @@
#include "lib.h"
#include "certs.h"
// Cert Sizes
u32 GetCertSize(u8 *cert)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
Cert_Struct *certcore = (Cert_Struct*)(cert+4+SigSize+SigPadding);
u32 PubKSectionSize = GetCertPubkSectionSize((pubk_types)u8_to_u32(certcore->KeyType,BE));
return (4+SigSize+SigPadding+sizeof(Cert_Struct)+PubKSectionSize);
}
void GetCertSigSectionSizes(u32 *SigSize, u32 *SigPadding, u8 *cert)
{
sig_types sig = (sig_types)u8_to_u32(cert,BE);
switch(sig){
case RSA_4096_SHA1 :
*SigSize = 0x200;
*SigPadding = 0x3C;
break;
case RSA_2048_SHA1 :
*SigSize = 0x100;
*SigPadding = 0x3C;
break;
case ECC_SHA1 :
*SigSize = 0x3C;
*SigPadding = 0x40;
break;
case RSA_4096_SHA256 :
*SigSize = 0x200;
*SigPadding = 0x3C;
break;
case RSA_2048_SHA256 :
*SigSize = 0x100;
*SigPadding = 0x3C;
break;
case ECC_SHA256 :
*SigSize = 0x3C;
*SigPadding = 0x40;
break;
default :
*SigSize = 0;
*SigPadding = 0;
break;
}
return;
}
u32 GetCertPubkSectionSize(pubk_types type)
{
switch(type){
case RSA_4096_PUBK : return sizeof(rsa_4096_pubk_struct);
case RSA_2048_PUBK : return sizeof(rsa_2048_pubk_struct);
case ECC_PUBK : return sizeof(ecc_pubk_struct);
default : return 0;
}
}
// Issuer/Name Functions
u8 *GetCertIssuer(u8 *cert)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
Cert_Struct *certcore = (Cert_Struct*)(cert+4+SigSize+SigPadding);
return certcore->Issuer;
}
u8 *GetCertName(u8 *cert)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
Cert_Struct *certcore = (Cert_Struct*)(cert+4+SigSize+SigPadding);
return certcore->Name;
}
int GenCertChildIssuer(u8 *dest, u8 *cert)
{
u8 *Issuer = GetCertIssuer(cert);
u8 *Name = GetCertName(cert);
u32 out_size = strlen((char*)Issuer) + strlen((char*)Name) + 1;
if(out_size > 0x40) return MEM_ERROR;
memcpy(dest,Issuer,strlen((char*)Issuer));
dest[strlen((char*)Issuer)] = '-';
memcpy((dest+strlen((char*)Issuer)+1),Name,strlen((char*)Name));
return 0;
}
// Pubk
pubk_types GetCertPubkType(u8 *cert)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
Cert_Struct *certcore = (Cert_Struct*)(cert+4+SigSize+SigPadding);
return (pubk_types)u8_to_u32(certcore->KeyType,BE);
}
u8 *GetCertPubk(u8 *cert)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
return (cert+4+SigSize+SigPadding+sizeof(Cert_Struct));
}
bool VerifyCert(u8 *cert, u8 *pubk)
{
u32 SigSize = 0;
u32 SigPadding = 0;
GetCertSigSectionSizes(&SigSize,&SigPadding,cert);
if(!SigSize || !SigPadding) return 0;
u8 *signature = (cert+4);
u8 *data = (cert+4+SigSize+SigPadding);
u32 datasize = sizeof(Cert_Struct) + GetCertPubkSectionSize(GetCertPubkType(cert));
int result = ctr_sig(data,datasize,signature,pubk,NULL,u8_to_u32(cert,BE),CTR_RSA_VERIFY);
if(result == 0) return true;
else return false;
}
certs.h
-47
View File
@@ -1,47 +0,0 @@
#ifndef _CERTS_H_
#define _CERTS_H_
typedef struct
{
u8 Issuer[0x40];
u8 KeyType[4];
u8 Name[0x40];
u8 Unknown[4];
} Cert_Struct;
typedef struct
{
u8 Modulus[0x200];
u8 PubExponent[4];
u8 Padding[0x34];
} rsa_4096_pubk_struct;
typedef struct
{
u8 Modulus[0x100];
u8 PubExponent[4];
u8 Padding[0x34];
} rsa_2048_pubk_struct;
typedef struct
{
u8 PubK[0x3C];
u8 Padding[0x3C];
} ecc_pubk_struct;
#endif
// Cert Sizes
u32 GetCertSize(u8 *cert);
void GetCertSigSectionSizes(u32 *SigSize, u32 *SigPadding, u8 *cert);
u32 GetCertPubkSectionSize(pubk_types type);
// Issuer/Name Functions
u8 *GetCertIssuer(u8 *cert);
u8 *GetCertName(u8 *cert);
int GenCertChildIssuer(u8 *dest, u8 *cert);
// Pubk
pubk_types GetCertPubkType(u8 *cert);
u8 *GetCertPubk(u8 *cert);
bool VerifyCert(u8 *cert, u8 *pubk);
cia.c
-617
View File
@@ -1,617 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "exheader.h"
#include "exefs.h"
#include "certs.h"
#include "cia.h"
#include "tik.h"
#include "tmd.h"
#include "titleid.h"
#include "srl.h"
#include "ncsd.h"
// Private Prototypes
/* cia_settings tools */
void init_CIASettings(cia_settings *set);
void free_CIASettings(cia_settings *set);
int get_CIASettings(cia_settings *ciaset, user_settings *usrset);
int GetSettingsFromUsrset(cia_settings *ciaset, user_settings *usrset);
int GetSettingsFromNcch0(cia_settings *ciaset, u32 ncch0_offset);
int GetCIADataFromNcch(cia_settings *ciaset, NCCH_Header *NcchHdr, ExtendedHeader_Struct *ExHeader);
int GetMetaRegion(cia_settings *ciaset, ExtendedHeader_Struct *ExHeader, u8 *ExeFs);
int GetContentFilePtrs(cia_settings *ciaset, user_settings *usrset);
int GetSettingsFromSrl(cia_settings *ciaset);
int GetSettingsFromCci(cia_settings *ciaset);
u16 SetupVersion(u16 Major, u16 Minor, u16 Micro);
int BuildCIA_CertChain(cia_settings *ciaset);
int BuildCIA_Header(cia_settings *ciaset);
int WriteCurrentSectionstoFile(cia_settings *ciaset);
int WriteContentsToFile(cia_settings *ciaset, user_settings *usrset);
int WriteTMDToFile(cia_settings *ciaset);
int CryptContent(u8 *EncBuffer,u8 *DecBuffer,u64 size,u8 *title_key, u16 index, u8 mode);
int build_CIA(user_settings *usrset)
{
int result = 0;
// Init Settings
cia_settings *ciaset = malloc(sizeof(cia_settings));
if(!ciaset) {fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR;}
init_CIASettings(ciaset);
// Get Settings
result = get_CIASettings(ciaset,usrset);
if(result) goto finish;
// Create Output File
ciaset->out = fopen(usrset->outfile,"wb");
if(!ciaset->out){
fprintf(stderr,"[CIA ERROR] Failed to create '%s'\n",usrset->outfile);
result = FAILED_TO_CREATE_OUTFILE;
goto finish;
}
// Create CIA Sections
/* Certificate Chain */
result = BuildCIA_CertChain(ciaset);
if(result) goto finish;
/* Ticket */
result = BuildTicket(ciaset);
if(result) goto finish;
/* CIA Header */
result = BuildCIA_Header(ciaset);
if(result) goto finish;
/* Write To File Current Sections to File */
/* Explanation :
In order to conserve memory, only one Content is in memory at a time.
This however has the limitation of only being able to generate TMD after all content
has been processed (, encrypted) and written to file.
*/
result = WriteCurrentSectionstoFile(ciaset);
if(result) goto finish;
result = WriteContentsToFile(ciaset, usrset);
if(result) goto finish;
result = BuildTMD(ciaset);
if(result) goto finish;
result = WriteTMDToFile(ciaset);
finish:
if(result != FAILED_TO_CREATE_OUTFILE && ciaset->out) fclose(ciaset->out);
free_CIASettings(ciaset);
return result;
}
void init_CIASettings(cia_settings *set)
{
memset(set,0,sizeof(cia_settings));
}
void free_CIASettings(cia_settings *set)
{
if(set->content.ContentFilePtrs){
for(u32 i = 1; i < set->content.ContentCount; i++){
fclose(set->content.ContentFilePtrs[i]);
}
free(set->content.ContentFilePtrs);
}
free(set->CIA_Sections.CertChain.buffer);
free(set->CIA_Sections.Ticket.buffer);
free(set->CIA_Sections.TitleMetaData.buffer);
free(set->CIA_Sections.CXI_MetaData.buffer);
memset(set,0,sizeof(cia_settings));
free(set);
}
int get_CIASettings(cia_settings *ciaset, user_settings *usrset)
{
int result = 0;
// Transfering data from usrset
result = GetSettingsFromUsrset(ciaset,usrset);
if(usrset->Content0IsNcch){
result = GetSettingsFromNcch0(ciaset,0);
if(result) return result;
result = GetContentFilePtrs(ciaset,usrset);
if(result) return result;
}
else if(usrset->Content0IsSrl){
result = GetSettingsFromSrl(ciaset);
if(result) return result;
}
else if(usrset->ConvertCci){
result = GetSettingsFromCci(ciaset);
if(result) return result;
}
return 0;
}
int GetSettingsFromUsrset(cia_settings *ciaset, user_settings *usrset)
{
// General Stuff
ciaset->keys = &usrset->keys;
ciaset->content.content0 = usrset->Content0.buffer;
ciaset->content.content0_FileLen = usrset->Content0.size;
u32_to_u8(ciaset->Title_type,TYPE_CTR,BE);
ciaset->content.EncryptContents = usrset->EncryptContents;
if(ciaset->keys->aes.CommonKey[ciaset->keys->aes.CurrentCommonKey] == NULL && ciaset->content.EncryptContents){
fprintf(stderr,"[CIA WARNING] Common Key could not be loaded, CIA will not be encrypted\n");
ciaset->content.EncryptContents = false;
}
ciaset->cert.ca_crl_version = 0;
ciaset->cert.signer_crl_version = 0;
for(int i = 0; i < 3; i++){
ciaset->Version[i] = usrset->Version[i];
}
// Random Number generator
u8 hash[0x20];
ctr_sha(ciaset->content.content0,0x100,hash,CTR_SHA_256);
// Ticket Data
memcpy(ciaset->tik.TicketID,(hash+0x8),8);
if(usrset->RandomTitleKey){
memcpy(ciaset->tik.TitleKey,(hash+0x10),16);
}
else{
memcpy(ciaset->tik.TitleKey,usrset->keys.aes.NormalKey,16);
}
ciaset->tik.ticket_format_ver = 1;
int result = GenCertChildIssuer(ciaset->tik.TicketIssuer,usrset->keys.certs.tik_cert);
if(result) return result;
// Tmd Stuff
if(usrset->ContentID[0] > 0xffffffff){
ciaset->content.ContentId[0] = u8_to_u32(hash,BE);
}
else ciaset->content.ContentId[0] = usrset->ContentID[0];
ciaset->tmd.tmd_format_ver = 1;
result = GenCertChildIssuer(ciaset->tmd.TMDIssuer,usrset->keys.certs.tmd_cert);
return 0;
}
int GetSettingsFromNcch0(cia_settings *ciaset, u32 ncch0_offset)
{
/* Sanity Checks */
if(!ciaset->content.content0_FileLen)
return CIA_NO_NCCH0;
u8 *ncch0 = (u8*)(ciaset->content.content0+ncch0_offset);
if(!IsNCCH(NULL,ncch0)){
fprintf(stderr,"[CIA ERROR] Content0 is not NCCH\n");
return CIA_INVALID_NCCH0;
}
/* Get Ncch0 Header */
NCCH_Header *hdr = NULL;
hdr = GetNCCH_CommonHDR(hdr,NULL,ncch0);
if(IsCfa(hdr)){
ciaset->content.IsCfa = true;
}
ciaset->content.ContentOffset[0] = 0;
ciaset->content.ContentSize[0] = GetNCCH_MediaSize(hdr)*GetNCCH_MediaUnitSize(hdr);
ciaset->content.TotalContentSize = ciaset->content.ContentSize[0];
/* Get Ncch0 Import Context */
NCCH_STRUCT *ncch_ctx = malloc(sizeof(NCCH_STRUCT));
if(!ncch_ctx){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
memset(ncch_ctx,0x0,sizeof(NCCH_STRUCT));
GetCXIStruct(ncch_ctx,hdr);
/* Verify Ncch0 (Sig&Hash Checks) */
int result = VerifyNCCH(ncch0,ciaset->keys,true);
if(result == UNABLE_TO_LOAD_NCCH_KEY){
ciaset->content.KeyNotFound = true;
if(!ciaset->content.IsCfa){
fprintf(stderr,"[CIA WARNING] CXI AES Key could not be loaded\n");
fprintf(stderr," Meta Region, SaveDataSize, Remaster Version cannot be obtained\n");
}
}
else if(result != 0){
fprintf(stderr,"[CIA ERROR] Content 0 Is Corrupt (res = %d)\n",result);
return CIA_INVALID_NCCH0;
}
/* Gen Settings From Ncch0 */
endian_memcpy(ciaset->TitleID,hdr->title_id,8,LE);
/* Getting ExeFs/ExHeader */
u8 *ExeFs = malloc(ncch_ctx->exefs_size);
if(!ExeFs){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
ExtendedHeader_Struct *ExHeader = malloc(ncch_ctx->exheader_size);
if(!ExHeader){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); free(ExeFs); return MEM_ERROR; }
if(!(ciaset->content.IsCfa||ciaset->content.KeyNotFound)) GetNCCHSection(ExeFs, ncch_ctx->exefs_size, 0, ncch0, ncch_ctx, ciaset->keys, ncch_exefs);
if(!(ciaset->content.IsCfa||ciaset->content.KeyNotFound)) GetNCCHSection((u8*)ExHeader, ncch_ctx->exheader_size, 0, ncch0, ncch_ctx, ciaset->keys, ncch_ExHeader);
result = GetCIADataFromNcch(ciaset,hdr,ExHeader); // Data For TMD
if(result) goto finish;
result = GetMetaRegion(ciaset,ExHeader,ExeFs); // Meta Region
/* Finish */
finish:
free(ExeFs);
free(ExHeader);
/* Return */
free(ncch_ctx);
return result;
}
int GetCIADataFromNcch(cia_settings *ciaset, NCCH_Header *NcchHdr, ExtendedHeader_Struct *ExHeader)
{
u16 Category = u8_to_u16((ciaset->TitleID+2),BE);
bool IsPatch = (Category == 0x000E);
if(IsPatch||ciaset->content.IsCfa||ciaset->content.KeyNotFound) u32_to_u8(ciaset->tmd.SaveDataSize,0,LE);
else u32_to_u8(ciaset->tmd.SaveDataSize,(u32)GetSaveDataSize_frm_exhdr(ExHeader),LE);
if(ciaset->content.IsCfa||ciaset->content.KeyNotFound){
if(ciaset->Version[0] == 0xffff){ // '-major' wasn't set
if(ciaset->content.IsCfa){ // Is a CFA and can be decrypted
fprintf(stderr,"[CIA ERROR] Invalid major version. Use '-major' option.\n");
return CIA_BAD_VERSION;
}
else // CXI which cannot be decrypted
ciaset->Version[0] = 0;
}
}
else{ // Is a CXI and can be decrypted
if(ciaset->Version[0] != 0xffff){ // '-major' was set
fprintf(stderr,"[CIA ERROR] Option '-major' cannot be applied for cxi.\n");
return CIA_BAD_VERSION;
}
// Setting remaster ver
ciaset->Version[0] = GetRemasterVersion_frm_exhdr(ExHeader);
}
SetupVersion(ciaset->Version[0],ciaset->Version[1],ciaset->Version[2]);
u16 version = SetupVersion(ciaset->Version[0],ciaset->Version[1],ciaset->Version[2]);
u16_to_u8(ciaset->tik.TicketVersion,version,BE);
u16_to_u8(ciaset->tmd.TitleVersion,version,BE);
return 0;
}
int GetMetaRegion(cia_settings *ciaset, ExtendedHeader_Struct *ExHeader, u8 *ExeFs)
{
if(ciaset->content.IsCfa || ciaset->content.KeyNotFound) return 0;
ciaset->CIA_Sections.CXI_MetaData.size = sizeof(MetaData_Struct) + GetExeFsSectionSize("icon",ExeFs);
ciaset->CIA_Sections.CXI_MetaData.buffer = malloc(ciaset->CIA_Sections.CXI_MetaData.size);
if(!ciaset->CIA_Sections.CXI_MetaData.buffer){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
MetaData_Struct *hdr = (MetaData_Struct*)ciaset->CIA_Sections.CXI_MetaData.buffer;
memset(hdr,0,sizeof(MetaData_Struct));
GetDependancyList_frm_exhdr(hdr->DependancyList,ExHeader);
GetCoreVersion_frm_exhdr(hdr->CoreVersion,ExHeader);
if(DoesExeFsSectionExist("icon",ExeFs)){
u8 *IconDestPos = (ciaset->CIA_Sections.CXI_MetaData.buffer + sizeof(MetaData_Struct));
memcpy(IconDestPos,GetExeFsSection("icon",ExeFs),GetExeFsSectionSize("icon",ExeFs));
}
return 0;
}
int GetContentFilePtrs(cia_settings *ciaset, user_settings *usrset)
{
ciaset->content.ContentFilePtrs = malloc(sizeof(FILE*)*CIA_MAX_CONTENT);
if(!ciaset->content.ContentFilePtrs){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
memset(ciaset->content.ContentFilePtrs,0,sizeof(FILE*)*CIA_MAX_CONTENT);
int j = 1;
NCCH_Header *hdr = malloc(sizeof(NCCH_Header));
for(int i = 1; i < CIA_MAX_CONTENT; i++){
if(usrset->ContentPath[i]){
ciaset->content.ContentFilePtrs[j] = fopen(usrset->ContentPath[i],"rb");
if(!ciaset->content.ContentFilePtrs[j]){ fprintf(stderr,"[CIA ERROR] Failed to open '%s'\n",usrset->ContentPath[i]); return FAILED_TO_OPEN_FILE; }
if(usrset->ContentID[i] == 0x100000000){
u8 hash[0x20];
ctr_sha(usrset->ContentPath[i],strlen(usrset->ContentPath[i]),hash,CTR_SHA_256);
ciaset->content.ContentId[j] = u8_to_u32(hash,BE);
}
else ciaset->content.ContentId[j] = (u32)usrset->ContentID[i];
ciaset->content.ContentIndex[j] = (u16)i;
// Get Data from ncch HDR
GetNCCH_CommonHDR(hdr,ciaset->content.ContentFilePtrs[j],NULL);
// Get TitleID
memcpy(ciaset->content.ContentTitleId[j],hdr->title_id,8);
// Get Size
ciaset->content.ContentSize[j] = GetNCCH_MediaSize(hdr)*GetNCCH_MediaUnitSize(hdr);
ciaset->content.ContentOffset[j] = ciaset->content.TotalContentSize;
ciaset->content.TotalContentSize += ciaset->content.ContentSize[j];
// Finish get next content
j++;
}
}
free(hdr);
ciaset->content.ContentCount = j;
// Check Conflicting IDs
for(int i = 0; i < ciaset->content.ContentCount; i++){
for(j = i+1; j < ciaset->content.ContentCount; j++){
if(ciaset->content.ContentId[j] == ciaset->content.ContentId[i]){
fprintf(stderr,"[CIA ERROR] CIA Content %d and %d, have conflicting IDs\n",ciaset->content.ContentIndex[j],ciaset->content.ContentIndex[i]);
return CIA_CONFILCTING_CONTENT_IDS;
}
}
}
return 0;
}
int GetSettingsFromSrl(cia_settings *ciaset)
{
SRL_Header *hdr = (SRL_Header*)ciaset->content.content0;
if(!hdr || ciaset->content.content0_FileLen < sizeof(SRL_Header)) {
fprintf(stderr,"[CIA ERROR] Invalid TWL SRL File\n");
return FAILED_TO_IMPORT_FILE;
}
// Check if TWL SRL File
if(u8_to_u16(&hdr->title_id[6],LE) != 0x0003){
fprintf(stderr,"[CIA ERROR] Invalid TWL SRL File\n");
return FAILED_TO_IMPORT_FILE;
}
// Generate and store Converted TitleID
u64_to_u8(ciaset->TitleID,ConvertTwlIdToCtrId(u8_to_u64(hdr->title_id,LE)),BE);
//memdump(stdout,"SRL TID: ",ciaset->TitleID,8);
// Get TWL Flag
ciaset->tmd.twl_flag = ((hdr->reserved_flags[3] & 6) >> 1);
// Get Remaster Version
u16 version = SetupVersion(hdr->rom_version,ciaset->Version[1],0);
u16_to_u8(ciaset->tik.TicketVersion,version,BE);
u16_to_u8(ciaset->tmd.TitleVersion,version,BE);
// Get SaveDataSize (Public and Private)
memcpy(ciaset->tmd.SaveDataSize,hdr->pub_save_data_size,4);
memcpy(ciaset->tmd.PrivSaveDataSize,hdr->priv_save_data_size,4);
// Setting CIA Content Settings
ciaset->content.ContentCount = 1;
ciaset->content.ContentOffset[0] = 0;
ciaset->content.ContentSize[0] = ciaset->content.content0_FileLen;
ciaset->content.TotalContentSize = ciaset->content.content0_FileLen;
return 0;
}
int GetSettingsFromCci(cia_settings *ciaset)
{
int result = 0;
if(!IsCci(ciaset->content.content0)){
fprintf(stderr,"[CIA ERROR] Invalid CCI file\n");
return FAILED_TO_IMPORT_FILE;
}
u32 ncch0_offset = GetPartitionOffset(ciaset->content.content0,0);
if(!ncch0_offset){
fprintf(stderr,"[CIA ERROR] Invalid CCI file (invalid ncch0 size)\n");
return FAILED_TO_IMPORT_FILE;
}
result = GetSettingsFromNcch0(ciaset, ncch0_offset);
if(result){
fprintf(stderr,"Import of Ncch 0 failed(%d)\n",result);
return result;
}
ciaset->content.ContentCount = 1;
ciaset->content.CCIContentOffsets[0] = ncch0_offset;
NCCH_Header *hdr = malloc(sizeof(NCCH_Header));
for(int i = 1; i < 8; i++){
if(GetPartitionSize(ciaset->content.content0,i)){
ciaset->content.CCIContentOffsets[ciaset->content.ContentCount] = GetPartitionOffset(ciaset->content.content0,i);
// Get Data from ncch HDR
GetNCCH_CommonHDR(hdr,NULL,GetPartition(ciaset->content.content0,i));
// Get Size
ciaset->content.ContentSize[ciaset->content.ContentCount] = GetPartitionSize(ciaset->content.content0,i);
ciaset->content.ContentOffset[ciaset->content.ContentCount] = ciaset->content.TotalContentSize;
ciaset->content.TotalContentSize += ciaset->content.ContentSize[ciaset->content.ContentCount];
// Get ID
u8 hash[0x20];
ctr_sha((u8*)hdr,0x200,hash,CTR_SHA_256);
ciaset->content.ContentId[ciaset->content.ContentCount] = u8_to_u32(hash,BE);
// Get Index
ciaset->content.ContentIndex[ciaset->content.ContentCount] = i;
// Increment Content Count
ciaset->content.ContentCount++;
}
}
free(hdr);
return 0;
}
u16 SetupVersion(u16 Major, u16 Minor, u16 Micro)
{
return (((Major << 10) & 0xFC00) | ((Minor << 4) & 0x3F0) | (Micro & 0xf));
}
int BuildCIA_CertChain(cia_settings *ciaset)
{
ciaset->CIA_Sections.CertChain.size = GetCertSize(ciaset->keys->certs.ca_cert) + GetCertSize(ciaset->keys->certs.tik_cert) + GetCertSize(ciaset->keys->certs.tmd_cert);
ciaset->CIA_Sections.CertChain.buffer = malloc(ciaset->CIA_Sections.CertChain.size);
if(!ciaset->CIA_Sections.CertChain.buffer) { fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
memcpy(ciaset->CIA_Sections.CertChain.buffer,ciaset->keys->certs.ca_cert,GetCertSize(ciaset->keys->certs.ca_cert));
memcpy((ciaset->CIA_Sections.CertChain.buffer+GetCertSize(ciaset->keys->certs.ca_cert)),ciaset->keys->certs.tik_cert,GetCertSize(ciaset->keys->certs.tik_cert));
memcpy((ciaset->CIA_Sections.CertChain.buffer+GetCertSize(ciaset->keys->certs.ca_cert)+GetCertSize(ciaset->keys->certs.tik_cert)),ciaset->keys->certs.tmd_cert,GetCertSize(ciaset->keys->certs.tmd_cert));
return 0;
}
int BuildCIA_Header(cia_settings *ciaset)
{
// Allocating memory for header
ciaset->CIA_Sections.Header.size = sizeof(CIA_Header);
ciaset->CIA_Sections.Header.buffer = malloc(ciaset->CIA_Sections.Header.size);
if(!ciaset->CIA_Sections.Header.buffer){ fprintf(stderr,"[CIA ERROR] MEM ERROR\n"); return MEM_ERROR; }
CIA_Header *hdr = (CIA_Header*)ciaset->CIA_Sections.Header.buffer;
// Clearing
memset(hdr,0,sizeof(CIA_Header));
// Predict TMD Size
ciaset->CIA_Sections.TitleMetaData.size = PredictTMDSize(ciaset->content.ContentCount);
// Setting Data
u32_to_u8(hdr->HdrSize,sizeof(CIA_Header),LE);
u16_to_u8(hdr->Type,0x0,LE);
u16_to_u8(hdr->Version,0x0,LE);
u32_to_u8(hdr->CertChainSize,ciaset->CIA_Sections.CertChain.size,LE);
u32_to_u8(hdr->TicketSize,ciaset->CIA_Sections.Ticket.size,LE);
u32_to_u8(hdr->TitleMetaDataSize,ciaset->CIA_Sections.TitleMetaData.size,LE);
u32_to_u8(hdr->CXI_MetaSize,ciaset->CIA_Sections.CXI_MetaData.size,LE);
u64_to_u8(hdr->ContentSize,ciaset->content.TotalContentSize,LE);
// Recording Offsets
ciaset->CIA_Sections.CertChainOffset = align_value(sizeof(CIA_Header),0x40);
ciaset->CIA_Sections.TicketOffset = align_value(ciaset->CIA_Sections.CertChainOffset+ciaset->CIA_Sections.CertChain.size,0x40);
ciaset->CIA_Sections.TitleMetaDataOffset = align_value(ciaset->CIA_Sections.TicketOffset+ciaset->CIA_Sections.Ticket.size,0x40);
ciaset->CIA_Sections.ContentOffset = align_value(ciaset->CIA_Sections.TitleMetaDataOffset+ciaset->CIA_Sections.TitleMetaData.size,0x40);
ciaset->CIA_Sections.CXI_MetaDataOffset = align_value(ciaset->CIA_Sections.ContentOffset+ciaset->content.TotalContentSize,0x40);
// SetCIAContentIndex, actually works for all index values now. CIA files generated can now hold, with
// validity, 65536 contents. Or at least have a content with index value of 65535.
for(int i = 0; i < ciaset->content.ContentCount; i++){
// This works by treating the 0x2000 byte index array as an array of 2048 u32 values
// Used for determining which u32 chunk to write the value to
u16 section = ciaset->content.ContentIndex[i]/32;
// Calculating the value added to the u32
u32 value = 0x80000000/(1<<ciaset->content.ContentIndex[i]);
// Retrieving current u32 block
u32 cur_content_index_section = u8_to_u32(hdr->ContentIndex+(sizeof(u32)*section),BE);
// Adding value to block
cur_content_index_section += value;
// Returning block
u32_to_u8(hdr->ContentIndex+(sizeof(u32)*section),cur_content_index_section,BE);
}
return 0;
}
int WriteCurrentSectionstoFile(cia_settings *ciaset)
{
WriteBuffer(ciaset->CIA_Sections.Header.buffer,ciaset->CIA_Sections.Header.size,0,ciaset->out);
WriteBuffer(ciaset->CIA_Sections.CertChain.buffer,ciaset->CIA_Sections.CertChain.size,ciaset->CIA_Sections.CertChainOffset,ciaset->out);
WriteBuffer(ciaset->CIA_Sections.Ticket.buffer,ciaset->CIA_Sections.Ticket.size,ciaset->CIA_Sections.TicketOffset,ciaset->out);
WriteBuffer(ciaset->CIA_Sections.CXI_MetaData.buffer,ciaset->CIA_Sections.CXI_MetaData.size,ciaset->CIA_Sections.CXI_MetaDataOffset,ciaset->out);
return 0;
}
int WriteContentsToFile(cia_settings *ciaset, user_settings *usrset)
{
u8 *Content0 = ciaset->content.content0;
if(usrset->ConvertCci) Content0 = (u8*)(ciaset->content.content0+ciaset->content.CCIContentOffsets[0]);
ctr_sha(Content0,ciaset->content.ContentSize[0],ciaset->content.ContentHash[0],CTR_SHA_256);
if(ciaset->content.EncryptContents) {
ciaset->content.ContentType[0] |= Encrypted;
CryptContent(Content0,Content0,ciaset->content.ContentSize[0],ciaset->tik.TitleKey,ciaset->content.ContentIndex[0],ENC);
}
WriteBuffer(Content0,ciaset->content.ContentSize[0],ciaset->content.ContentOffset[0]+ciaset->CIA_Sections.ContentOffset,ciaset->out);
// Free Buffer if Not CCI
if(!usrset->ConvertCci){
free(usrset->Content0.buffer);
usrset->Content0.buffer = NULL;
usrset->Content0.size = 0;
}
// Add additional contents, recreating them with their new TitleID
if(usrset->Content0IsNcch){
u8 TitleId[8];
endian_memcpy(TitleId,ciaset->TitleID,8,LE);
for(int i = 1; i < ciaset->content.ContentCount; i++){
u8 *ContentBuff = RetargetNCCH(ciaset->content.ContentFilePtrs[i],ciaset->content.ContentSize[i],ciaset->content.ContentTitleId[i],TitleId,ciaset->keys);
if(!ContentBuff){
fprintf(stderr,"[CIA ERROR] Could not import content %d to CIA\n",i);
return FAILED_TO_IMPORT_FILE;
}
ctr_sha(ContentBuff,ciaset->content.ContentSize[i],ciaset->content.ContentHash[i],CTR_SHA_256);
if(ciaset->content.EncryptContents) {
ciaset->content.ContentType[i] |= Encrypted;
CryptContent(ContentBuff,ContentBuff,ciaset->content.ContentSize[i],ciaset->tik.TitleKey,ciaset->content.ContentIndex[i],ENC);
}
WriteBuffer(ContentBuff,ciaset->content.ContentSize[i],ciaset->content.ContentOffset[i]+ciaset->CIA_Sections.ContentOffset,ciaset->out);
free(ContentBuff);
}
}
else if(usrset->ConvertCci){
for(int i = 1; i < ciaset->content.ContentCount; i++){
u8 *ContentBuff = (u8*)(ciaset->content.content0+ciaset->content.CCIContentOffsets[i]);
ctr_sha(ContentBuff,ciaset->content.ContentSize[i],ciaset->content.ContentHash[i],CTR_SHA_256);
if(ciaset->content.EncryptContents) {
ciaset->content.ContentType[i] |= Encrypted;
CryptContent(ContentBuff,ContentBuff,ciaset->content.ContentSize[i],ciaset->tik.TitleKey,ciaset->content.ContentIndex[i],ENC);
}
WriteBuffer(ContentBuff,ciaset->content.ContentSize[i],ciaset->content.ContentOffset[i]+ciaset->CIA_Sections.ContentOffset,ciaset->out);
}
free(usrset->Content0.buffer);
usrset->Content0.buffer = NULL;
usrset->Content0.size = 0;
}
return 0;
}
int WriteTMDToFile(cia_settings *ciaset)
{
WriteBuffer(ciaset->CIA_Sections.TitleMetaData.buffer,ciaset->CIA_Sections.TitleMetaData.size,ciaset->CIA_Sections.TitleMetaDataOffset,ciaset->out);
return 0;
}
int CryptContent(u8 *EncBuffer,u8 *DecBuffer,u64 size,u8 *title_key, u16 index, u8 mode)
{
//generating IV
u8 iv[16];
memset(&iv,0x0,16);
iv[0] = (index >> 8) & 0xff;
iv[1] = index & 0xff;
//Crypting content
ctr_aes_context ctx;
memset(&ctx,0x0,sizeof(ctr_aes_context));
ctr_init_aes_cbc(&ctx,title_key,iv,mode);
if(mode == ENC) ctr_aes_cbc(&ctx,DecBuffer,EncBuffer,size,ENC);
else ctr_aes_cbc(&ctx,EncBuffer,DecBuffer,size,DEC);
return 0;
}
cia.h
-108
View File
@@ -1,108 +0,0 @@
// Enums
typedef enum
{
CIA_NO_NCCH0 = -1,
CIA_INVALID_NCCH0 = -2,
CIA_CONFILCTING_CONTENT_IDS = -3,
CIA_BAD_VERSION = -4,
} cia_errors;
// Structs
typedef struct
{
u8 HdrSize[4];
u8 Type[2];
u8 Version[2];
u8 CertChainSize[4];
u8 TicketSize[4];
u8 TitleMetaDataSize[4];
u8 CXI_MetaSize[4];
u8 ContentSize[8];
u8 ContentIndex[0x2000];
} CIA_Header;
typedef struct
{
u8 DependancyList[0x30*0x8];
u8 Reserved0[0x180];
u8 CoreVersion[4];
u8 Reserved1[0xfc];
} MetaData_Struct;
typedef struct
{
FILE *out;
u8 TitleID[8];
u8 Title_type[4];
u16 Version[3];
keys_struct *keys;
struct{
u8 ca_crl_version;
u8 signer_crl_version;
} cert;
struct{
u8 TicketIssuer[0x40];
u8 ticket_format_ver;
u8 TicketID[8];
u8 DeviceID[8];
u8 TicketVersion[3];
u8 TitleKey[16];
} tik;
struct{
u8 TMDIssuer[0x40];
u8 tmd_format_ver;
u8 TitleVersion[3];
u8 SaveDataSize[4];
u8 PrivSaveDataSize[4];
u8 twl_flag;
} tmd;
struct{
u8 *content0;
u64 content0_FileLen;
bool IsCfa;
bool KeyNotFound;
bool EncryptContents;
FILE **ContentFilePtrs;
u64 CCIContentOffsets[CCI_MAX_CONTENT];
u16 ContentCount;
u64 ContentSize[CIA_MAX_CONTENT];
u64 ContentOffset[CIA_MAX_CONTENT];
u16 ContentIndex[CIA_MAX_CONTENT];
u16 ContentType[CIA_MAX_CONTENT];
u32 ContentId[CIA_MAX_CONTENT];
u8 ContentHash[CIA_MAX_CONTENT][0x20];
u8 ContentTitleId[CIA_MAX_CONTENT][8];
u64 TotalContentSize;
} content;
struct{
COMPONENT_STRUCT Header;
u32 CertChainOffset;
COMPONENT_STRUCT CertChain;
u32 TicketOffset;
COMPONENT_STRUCT Ticket;
u32 TitleMetaDataOffset;
COMPONENT_STRUCT TitleMetaData;
u32 CXI_MetaDataOffset;
COMPONENT_STRUCT CXI_MetaData;
u64 ContentOffset;
} CIA_Sections;
// Finish CIA data req.
} cia_settings;
// Public Prototypes
int build_CIA(user_settings *usrset);
cia_certificates.h
-670
View File
@@ -1,670 +0,0 @@
#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
crypto.c
-423
View File
@@ -1,423 +0,0 @@
#include "lib.h"
#include "crypto.h"
// API for polarssl adapted/copied from CTRTOOL by neimod
void ctr_sha(void *data, u64 size, u8 *hash, int mode)
{
switch(mode){
case(CTR_SHA_1): sha1((u8*)data, size, hash); break;
case(CTR_SHA_256): sha2((u8*)data, size, hash, 0); break;
}
}
void ctr_add_counter(ctr_aes_context* ctx, u32 carry)
{
u32 counter[4];
u32 sum;
int i;
for(i=0; i<4; i++)
counter[i] = (ctx->ctr[i*4+0]<<24) | (ctx->ctr[i*4+1]<<16) | (ctx->ctr[i*4+2]<<8) | (ctx->ctr[i*4+3]<<0);
for(i=3; i>=0; i--)
{
sum = counter[i] + carry;
if (sum < counter[i])
carry = 1;
else
carry = 0;
counter[i] = sum;
}
for(i=0; i<4; i++)
{
ctx->ctr[i*4+0] = counter[i]>>24;
ctx->ctr[i*4+1] = counter[i]>>16;
ctx->ctr[i*4+2] = counter[i]>>8;
ctx->ctr[i*4+3] = counter[i]>>0;
}
}
void ctr_init_counter(ctr_aes_context* ctx, u8 key[16], u8 ctr[16])
{
aes_setkey_enc(&ctx->aes, key, 128);
memcpy(ctx->ctr, ctr, 16);
}
void ctr_crypt_counter_block(ctr_aes_context* ctx, u8 input[16], u8 output[16])
{
int i;
u8 stream[16];
aes_crypt_ecb(&ctx->aes, AES_ENCRYPT, ctx->ctr, stream);
if (input)
{
for(i=0; i<16; i++)
{
output[i] = stream[i] ^ input[i];
}
}
else
{
for(i=0; i<16; i++)
output[i] = stream[i];
}
ctr_add_counter(ctx, 1);
}
void ctr_crypt_counter(ctr_aes_context* ctx, u8* input, u8* output, u32 size)
{
u8 stream[16];
u32 i;
while(size >= 16)
{
ctr_crypt_counter_block(ctx, input, output);
if (input)
input += 16;
if (output)
output += 16;
size -= 16;
}
if (size)
{
memset(stream, 0, 16);
ctr_crypt_counter_block(ctx, stream, stream);
if (input)
{
for(i=0; i<size; i++)
output[i] = input[i] ^ stream[i];
}
else
{
memcpy(output, stream, size);
}
}
}
void ctr_init_aes_cbc(ctr_aes_context* ctx,u8 key[16],u8 iv[16], u8 mode)
{
switch(mode){
case(ENC): aes_setkey_enc(&ctx->aes, key, 128); break;
case(DEC): aes_setkey_dec(&ctx->aes, key, 128); break;
}
memcpy(ctx->iv, iv, 16);
}
void ctr_aes_cbc(ctr_aes_context* ctx,u8* input,u8* output,u32 size,u8 mode)
{
switch(mode){
case(ENC): aes_crypt_cbc(&ctx->aes, AES_ENCRYPT, size, ctx->iv, input, output); break;
case(DEC): aes_crypt_cbc(&ctx->aes, AES_DECRYPT, size, ctx->iv, input, output); break;
}
}
void ctr_rsa_free(ctr_rsa_context* ctx)
{
rsa_free(&ctx->rsa);
}
int ctr_rsa_init(ctr_rsa_context* ctx, u8 *modulus, u8 *private_exp, u8 *exponent, u8 rsa_type, u8 mode)
{
// Sanity Check
if(ctx == NULL || modulus == NULL ||(private_exp == NULL && mode == RSAKEY_PRIV) || (exponent == NULL && mode == RSAKEY_PUB))
return Fail;
rsa_init(&ctx->rsa, RSA_PKCS_V15, 0);
u16 n_size = 0;
u16 d_size = 0;
u16 e_size = 0;
switch(rsa_type){
case RSA_2048:
ctx->rsa.len = 0x100;
n_size = 0x100;
d_size = 0x100;
e_size = 3;
break;
case RSA_4096:
ctx->rsa.len = 0x200;
n_size = 0x200;
d_size = 0x200;
e_size = 3;
break;
default: return Fail;
}
switch(mode){
case(RSAKEY_PUB):
if (mpi_read_binary(&ctx->rsa.N, modulus, n_size))
goto clean;
if (mpi_read_binary(&ctx->rsa.E, exponent, e_size))
goto clean;
break;
case(RSAKEY_PRIV):
if (mpi_read_binary(&ctx->rsa.N, modulus, n_size))
goto clean;
if (mpi_read_binary(&ctx->rsa.D, private_exp, d_size))
goto clean;
break;
default: return Fail;
}
return Good;
clean:
ctr_rsa_free(ctx);
return Fail;
}
int ctr_sig(void *data, u64 size, u8 *signature, u8 *modulus, u8 *private_exp, u32 type, u8 mode)
{
int result = 0;
int hashtype, hashlen, sigtype;
if(data == NULL || signature == NULL || modulus == NULL ||(private_exp == NULL && mode == CTR_RSA_SIGN))
return Fail;
switch(type){
case RSA_4096_SHA1:
hashtype = CTR_SHA_1;
hashlen = 0x14;
sigtype = RSA_4096;
case RSA_4096_SHA256:
hashtype = CTR_SHA_256;
hashlen = 0x20;
sigtype = RSA_4096;
break;
case RSA_2048_SHA1:
hashtype = CTR_SHA_1;
hashlen = 0x14;
sigtype = RSA_2048;
case RSA_2048_SHA256:
hashtype = CTR_SHA_256;
hashlen = 0x20;
sigtype = RSA_2048;
break;
case ECC_SHA1:
hashtype = CTR_SHA_1;
hashlen = 0x14;
sigtype = ECC;
case ECC_SHA256:
hashtype = CTR_SHA_256;
hashlen = 0x20;
sigtype = ECC;
break;
default: return Fail;
}
u8 hash[hashlen];
memset(hash,0,hashlen);
ctr_sha(data,size,hash,hashtype);
//memdump(stdout,"Data: ",data,size);
//memdump(stdout,"HashFor Sig: ",hash,hashlen);
if(sigtype == RSA_2048 || sigtype == RSA_4096)
result = ctr_rsa(hash,signature,modulus,private_exp,type,mode);
else if(sigtype == ECC){
printf("[!] ECC is not yet implemented\n");
result = Fail;
}
return result;
}
int ctr_rsa(u8 *hash, u8 *signature, u8 *modulus, u8 *private_exp, u32 type, u8 mode)
{
int result = 0;
// Sanity Check
if(hash == NULL || signature == NULL || modulus == NULL ||(private_exp == NULL && mode == CTR_RSA_SIGN))
return Fail;
// Getting details from sig type
int hashtype;
int hashlen;
int sigtype;
switch(type){
case RSA_4096_SHA1:
hashtype = SIG_RSA_SHA1;
hashlen = 0x14;
sigtype = RSA_4096;
break;
case RSA_4096_SHA256:
hashtype = SIG_RSA_SHA256;
hashlen = 0x14;
sigtype = RSA_4096;
break;
case RSA_2048_SHA1:
hashtype = SIG_RSA_SHA1;
hashlen = 0x20;
sigtype = RSA_2048;
break;
case RSA_2048_SHA256:
hashtype = SIG_RSA_SHA256;
hashlen = 0x20;
sigtype = RSA_2048;
break;
default: return Fail;
}
// Setting up
ctr_rsa_context ctx;
u8 exponent[3] = {0x01,0x00,0x01};
switch(mode){
case CTR_RSA_VERIFY:
result = ctr_rsa_init(&ctx,modulus,NULL,(u8*)exponent,sigtype,RSAKEY_PUB);
break;
case CTR_RSA_SIGN:
result = ctr_rsa_init(&ctx,modulus,private_exp,NULL,sigtype,RSAKEY_PRIV);
break;
}
if(result)return result;
switch(mode){
case CTR_RSA_VERIFY:
return rsa_pkcs1_verify(&ctx.rsa,RSA_PUBLIC,hashtype,hashlen,hash,signature);
case CTR_RSA_SIGN:
return ctr_rsa_rsassa_pkcs1_v15_sign(&ctx.rsa,RSA_PRIVATE,hashtype,hashlen,hash,signature);
}
return Fail;
}
/**
* Hacked from rsa.c, polarssl doesn't like generating signatures when only D and N are present
**/
int ctr_rsa_rsassa_pkcs1_v15_sign( rsa_context *ctx,
int mode,
int hash_id,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
{
size_t nb_pad, olen, ret;
unsigned char *p = sig;
if( ctx->padding != RSA_PKCS_V15 )
return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
switch( hash_id )
{
case SIG_RSA_RAW:
nb_pad = olen - 3 - hashlen;
break;
case SIG_RSA_MD2:
case SIG_RSA_MD4:
case SIG_RSA_MD5:
nb_pad = olen - 3 - 34;
break;
case SIG_RSA_SHA1:
nb_pad = olen - 3 - 35;
break;
case SIG_RSA_SHA224:
nb_pad = olen - 3 - 47;
break;
case SIG_RSA_SHA256:
nb_pad = olen - 3 - 51;
break;
case SIG_RSA_SHA384:
nb_pad = olen - 3 - 67;
break;
case SIG_RSA_SHA512:
nb_pad = olen - 3 - 83;
break;
default:
return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
}
if( ( nb_pad < 8 ) || ( nb_pad > olen ) )
return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
*p++ = 0;
*p++ = RSA_SIGN;
memset( p, 0xFF, nb_pad );
p += nb_pad;
*p++ = 0;
switch( hash_id )
{
case SIG_RSA_RAW:
memcpy( p, hash, hashlen );
break;
case SIG_RSA_MD2:
memcpy( p, ASN1_HASH_MDX, 18 );
memcpy( p + 18, hash, 16 );
p[13] = 2; break;
case SIG_RSA_MD4:
memcpy( p, ASN1_HASH_MDX, 18 );
memcpy( p + 18, hash, 16 );
p[13] = 4; break;
case SIG_RSA_MD5:
memcpy( p, ASN1_HASH_MDX, 18 );
memcpy( p + 18, hash, 16 );
p[13] = 5; break;
case SIG_RSA_SHA1:
memcpy( p, ASN1_HASH_SHA1, 15 );
memcpy( p + 15, hash, 20 );
break;
case SIG_RSA_SHA224:
memcpy( p, ASN1_HASH_SHA2X, 19 );
memcpy( p + 19, hash, 28 );
p[1] += 28; p[14] = 4; p[18] += 28; break;
case SIG_RSA_SHA256:
memcpy( p, ASN1_HASH_SHA2X, 19 );
memcpy( p + 19, hash, 32 );
p[1] += 32; p[14] = 1; p[18] += 32; break;
case SIG_RSA_SHA384:
memcpy( p, ASN1_HASH_SHA2X, 19 );
memcpy( p + 19, hash, 48 );
p[1] += 48; p[14] = 2; p[18] += 48; break;
case SIG_RSA_SHA512:
memcpy( p, ASN1_HASH_SHA2X, 19 );
memcpy( p + 19, hash, 64 );
p[1] += 64; p[14] = 3; p[18] += 64; break;
default:
return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
}
mpi T, T1, T2;
mpi_init( &T ); mpi_init( &T1 ); mpi_init( &T2 );
MPI_CHK( mpi_read_binary( &T, sig, ctx->len ) );
if( mpi_cmp_mpi( &T, &ctx->N ) >= 0 )
{
mpi_free( &T );
return( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
}
MPI_CHK( mpi_exp_mod( &T, &T, &ctx->D, &ctx->N, &ctx->RN ) );
MPI_CHK( mpi_write_binary( &T, sig, olen ) );
cleanup:
mpi_free( &T ); mpi_free( &T1 ); mpi_free( &T2 );
return( 0 );
}
crypto.h
-101
View File
@@ -1,101 +0,0 @@
#ifndef _CTR_CRYPTO_H_
#define _CTR_CRYPTO_H_
#include "polarssl/config.h"
#include "polarssl/aes.h"
#include "polarssl/rsa.h"
#include "polarssl/sha1.h"
#include "polarssl/sha2.h"
typedef enum
{
RSA_4096_SHA1 = 0x00010000,
RSA_2048_SHA1 = 0x00010001,
ECC_SHA1 = 0x00010002,
RSA_4096_SHA256 = 0x00010003,
RSA_2048_SHA256 = 0x00010004,
ECC_SHA256 = 0x00010005
} sig_types;
typedef enum
{
RSA_2048 = 0,
RSA_4096 = 1,
ECC = 2,
} ctr_sig_types;
typedef enum
{
CTR_RSA_VERIFY = 0,
CTR_RSA_SIGN = 1,
} ctr_rsa_functions;
typedef enum
{
CTR_SHA_1 = 1,
CTR_SHA_256 = 256,
} ctr_sha_modes;
typedef enum
{
RSA_4096_PUBK = 0,
RSA_2048_PUBK,
ECC_PUBK
} pubk_types;
typedef enum
{
ENC,
DEC
} aescbcmode;
typedef enum
{
RSAKEY_INVALID,
RSAKEY_PRIV,
RSAKEY_PUB
} rsakeytype;
typedef struct
{
u8 ctr[16];
u8 iv[16];
aes_context aes;
} ctr_aes_context;
typedef struct
{
rsa_context rsa;
} ctr_rsa_context;
#ifdef __cplusplus
extern "C" {
#endif
// SHA
void ctr_sha(void *data, u64 size, u8 *hash, int mode);
// AES
void ctr_add_counter(ctr_aes_context* ctx, u32 carry);
void ctr_init_counter(ctr_aes_context* ctx, u8 key[16],u8 ctr[16]);
void ctr_crypt_counter_block(ctr_aes_context* ctx, u8 input[16], u8 output[16]);
void ctr_crypt_counter(ctr_aes_context* ctx, u8* input, u8* output, u32 size);
void ctr_init_aes_cbc(ctr_aes_context* ctx,u8 key[16],u8 iv[16], u8 mode);
void ctr_aes_cbc(ctr_aes_context* ctx,u8* input,u8* output,u32 size,u8 mode);
// RSA
void ctr_rsa_free(ctr_rsa_context* ctx);
int ctr_rsa_init(ctr_rsa_context* ctx, u8 *modulus, u8 *private_exp, u8 *exponent, u8 rsa_type, u8 mode);
int ctr_rsa(u8 *hash, u8 *signature, u8 *modulus, u8 *private_exp, u32 type, u8 mode);
int ctr_rsa_rsassa_pkcs1_v15_sign( rsa_context *ctx,
int mode,
int hash_id,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig );
// Signature Functions
int ctr_sig(void *data, u64 size, u8 *signature, u8 *modulus, u8 *private_exp, u32 type, u8 mode);
#ifdef __cplusplus
}
#endif
#endif
elf.c
-977
View File
@@ -1,977 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "elf_hdr.h"
#include "elf.h"
#include "blz.h"
int ImportPlainRegionFromFile(ncch_settings *ncchset);
int ImportExeFsCodeBinaryFromFile(ncch_settings *ncchset);
u32 GetPageSize(ncch_settings *ncchset);
u32 SizeToPage(u32 memorySize, ElfContext *elf);
int GetBSS_SizeFromElf(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset);
int ImportPlainRegionFromElf(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset);
int CreateExeFsCode(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset);
int CreateCodeSegmentFromElf(CodeSegment *out, ElfContext *elf, u8 *ElfFile, char **Names, u32 NameNum);
ElfSegment** GetContinuousSegments(u16 *ContinuousSegmentNum, ElfContext *elf, char **Names, u32 NameNum);
ElfSegment** GetSegments(u16 *SegmentNum, ElfContext *elf, char **Names, u32 NameNum);
// ELF Functions
int GetElfContext(ElfContext *elf, u8 *ElfFile);
int GetElfSectionEntries(ElfContext *elf, u8 *ElfFile);
int GetElfProgramEntries(ElfContext *elf, u8 *ElfFile);
void PrintElfContext(ElfContext *elf, u8 *ElfFile);
int ReadElfHdr(ElfContext *elf, u8 *ElfFile);
int CreateElfSegments(ElfContext *elf, u8 *ElfFile);
bool IsIgnoreSection(ElfSectionEntry info);
/* ELF Section Entry Functions */
u8* GetELFSectionHeader(u16 Index, ElfContext *elf, u8 *ElfFile);
u8* GetELFSectionEntry(u16 Index, ElfContext *elf, u8 *ElfFile);
char* GetELFSectionEntryName(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntryType(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntryFlags(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntryAddress(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntryFileOffset(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntrySize(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFSectionEntryAlignment(u16 Index, ElfContext *elf, u8 *ElfFile);
u16 GetElfSectionIndexFromName(char *Name, ElfContext *elf, u8 *ElfFile);
bool IsBss(ElfSectionEntry *Section);
bool IsData(ElfSectionEntry *Section);
bool IsRO(ElfSectionEntry *Section);
bool IsText(ElfSectionEntry *Section);
/* ELF Program Entry Functions */
u8* GetELFProgramHeader(u16 Index, ElfContext *elf, u8 *ElfFile);
u8* GetELFProgramEntry(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryType(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryFlags(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryFileSize(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryFileOffset(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryMemorySize(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryVAddress(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryPAddress(u16 Index, ElfContext *elf, u8 *ElfFile);
u64 GetELFProgramEntryAlignment(u16 Index, ElfContext *elf, u8 *ElfFile);
int BuildExeFsCode(ncch_settings *ncchset)
{
int result = 0;
if(ncchset->ComponentFilePtrs.plainregion){ // Import PlainRegion from file
result = ImportPlainRegionFromFile(ncchset);
if(result) return result;
}
if(!ncchset->Options.IsBuildingCodeSection){ // Import ExeFs Code from file and return
result = ImportExeFsCodeBinaryFromFile(ncchset);
return result;
}
#ifdef DEBUG
printf("[DEBUG] Import ELF\n");
#endif
/* Import ELF */
u8 *ElfFile = malloc(ncchset->ComponentFilePtrs.elf_size);
if(!ElfFile) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ElfFile,ncchset->ComponentFilePtrs.elf_size,0,ncchset->ComponentFilePtrs.elf);
#ifdef DEBUG
printf("[DEBUG] Create ELF Context\n");
#endif
/* Create ELF Context */
ElfContext *elf = malloc(sizeof(ElfContext));
if(!elf) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); free(ElfFile); return MEM_ERROR;}
memset(elf,0,sizeof(ElfContext));
result = GetElfContext(elf,ElfFile);
if(result) goto finish;
/* Setting Page Size */
elf->PageSize = GetPageSize(ncchset);
if(!ncchset->ComponentFilePtrs.plainregion){
result = ImportPlainRegionFromElf(elf,ElfFile,ncchset);
if(result) goto finish;
}
#ifdef ELF_DEBUG
PrintElfContext(elf,ElfFile);
#endif
#ifdef DEBUG
PrintElfContext(elf,ElfFile);
#endif
#ifdef DEBUG
printf("[DEBUG] Create ExeFs Code\n");
#endif
result = CreateExeFsCode(elf,ElfFile,ncchset);
if(result) goto finish;
#ifdef DEBUG
printf("[DEBUG] Get BSS Size\n");
#endif
result = GetBSS_SizeFromElf(elf,ElfFile,ncchset);
if(result) goto finish;
finish:
if(result){
if(result == NOT_ELF_FILE) fprintf(stderr,"[ELF ERROR] Not ELF File\n");
else if(result == NOT_ARM_ELF) fprintf(stderr,"[ELF ERROR] Not ARM ELF\n");
else if(result == NON_EXECUTABLE_ELF) fprintf(stderr,"[ELF ERROR] Not Executeable ELF\n");
else if(result == NOT_FIND_BSS_SIZE) fprintf(stderr,"[ELF ERROR] BSS Size Could not be found\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);
}
#ifdef DEBUG
printf("[DEBUG] Free Segment Header/Sections\n");
#endif
for(int i = 0; i < elf->ActiveSegments; i++){
#ifdef DEBUG
printf("[DEBUG] %d\n",i);
#endif
free(elf->Segments[i].Sections);
}
#ifdef DEBUG
printf("[DEBUG] Free others\n");
#endif
free(ElfFile);
free(elf->Sections);
free(elf->ProgramHeaders);
free(elf->Segments);
free(elf);
return result;
}
int ImportPlainRegionFromFile(ncch_settings *ncchset)
{
ncchset->Sections.PlainRegion.size = align_value(ncchset->ComponentFilePtrs.plainregion_size,ncchset->Options.MediaSize);
ncchset->Sections.PlainRegion.buffer = malloc(ncchset->Sections.PlainRegion.size);
if(!ncchset->Sections.PlainRegion.buffer) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ncchset->Sections.PlainRegion.buffer,ncchset->ComponentFilePtrs.plainregion_size,0,ncchset->ComponentFilePtrs.plainregion);
return 0;
}
int ImportExeFsCodeBinaryFromFile(ncch_settings *ncchset)
{
u32 size = ncchset->ComponentFilePtrs.code_size;
u8 *buffer = malloc(size);
if(!buffer) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(buffer,size,0,ncchset->ComponentFilePtrs.code);
ncchset->ExeFs_Sections.Code.size = ncchset->ComponentFilePtrs.code_size;
ncchset->ExeFs_Sections.Code.buffer = malloc(ncchset->ExeFs_Sections.Code.size);
if(!ncchset->ExeFs_Sections.Code.buffer) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ncchset->ExeFs_Sections.Code.buffer,ncchset->ExeFs_Sections.Code.size,0,ncchset->ComponentFilePtrs.code);
if(ncchset->Options.CompressCode){
u32 new_len;
ncchset->ExeFs_Sections.Code.buffer = BLZ_Code(buffer,size,&new_len,BLZ_NORMAL);
ncchset->ExeFs_Sections.Code.size = new_len;
free(buffer);
}
else{
ncchset->ExeFs_Sections.Code.size = size;
ncchset->ExeFs_Sections.Code.buffer = buffer;
}
return 0;
}
u32 GetPageSize(ncch_settings *ncchset)
{
if(ncchset->yaml_set->Option.PageSize)
return strtoul(ncchset->yaml_set->Option.PageSize,NULL,10);
return 0x1000;
}
u32 SizeToPage(u32 memorySize, ElfContext *elf)
{
return align_value(memorySize,elf->PageSize)/elf->PageSize;
}
int GetBSS_SizeFromElf(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset)
{
for(int i = 0; i < elf->SectionTableEntryCount; i++){
if(IsBss(&elf->Sections[i])) {
ncchset->CodeDetails.BSS_Size = elf->Sections[i].Size;
return 0;
}
}
return NOT_FIND_BSS_SIZE;
}
int ImportPlainRegionFromElf(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset) // Doesn't work same as N makerom
{
if(!ncchset->yaml_set->PlainRegionNum) return 0;
u16 *Index = malloc(sizeof(u16)*ncchset->yaml_set->PlainRegionNum);
/* Getting Index Values for each section */
for(int i = 0; i < ncchset->yaml_set->PlainRegionNum; i++){
Index[i] = GetElfSectionIndexFromName(ncchset->yaml_set->PlainRegion[i],elf,ElfFile);
}
// Eliminating Duplicated Sections
for(int i = ncchset->yaml_set->PlainRegionNum - 1; i >= 0; i--){
for(int j = i-1; j >= 0; j--){
if(Index[i] == Index[j]) Index[i] = 0;
}
}
/* Calculating Total Size of Data */
u64 TotalSize = 0;
for(int i = 0; i < ncchset->yaml_set->PlainRegionNum; i++){
TotalSize += elf->Sections[Index[i]].Size;
}
/* Creating Output Buffer */
ncchset->Sections.PlainRegion.size = align_value(TotalSize,ncchset->Options.MediaSize);
ncchset->Sections.PlainRegion.buffer = malloc(ncchset->Sections.PlainRegion.size);
if(!ncchset->Sections.PlainRegion.buffer) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
memset(ncchset->Sections.PlainRegion.buffer,0,ncchset->Sections.PlainRegion.size);
/* Storing Sections */
u64 pos = 0;
for(int i = 0; i < ncchset->yaml_set->PlainRegionNum; i++){
memcpy((ncchset->Sections.PlainRegion.buffer+pos),elf->Sections[Index[i]].Ptr,elf->Sections[Index[i]].Size);
pos += elf->Sections[Index[i]].Size;
}
return 0;
}
int CreateExeFsCode(ElfContext *elf, u8 *ElfFile, ncch_settings *ncchset)
{
/* Getting Code Segments */
CodeSegment Text;
memset(&Text,0,sizeof(CodeSegment));
CodeSegment RO;
memset(&RO,0,sizeof(CodeSegment));
CodeSegment Data;
memset(&Data,0,sizeof(CodeSegment));
int result = CreateCodeSegmentFromElf(&Text,elf,ElfFile,ncchset->yaml_set->ExeFs.Text,ncchset->yaml_set->ExeFs.TextNum);
if(result) return result;
result = CreateCodeSegmentFromElf(&RO,elf,ElfFile,ncchset->yaml_set->ExeFs.ReadOnly,ncchset->yaml_set->ExeFs.ReadOnlyNum);
if(result) return result;
result = CreateCodeSegmentFromElf(&Data,elf,ElfFile,ncchset->yaml_set->ExeFs.ReadWrite,ncchset->yaml_set->ExeFs.ReadWriteNum);
if(result) return result;
/* Allocating Buffer for ExeFs Code */
u32 size = (Text.MaxPageNum + RO.MaxPageNum + Data.MaxPageNum)*elf->PageSize;
u8 *code = malloc(size);
/* Writing Code into Buffer */
u8 *TextPos = (code + 0);
u8 *ROPos = (code + Text.MaxPageNum*elf->PageSize);
u8 *DataPos = (code + (Text.MaxPageNum + RO.MaxPageNum)*elf->PageSize);
if(Text.Size) memcpy(TextPos,Text.Data,Text.Size);
if(RO.Size) memcpy(ROPos,RO.Data,RO.Size);
if(Data.Size) memcpy(DataPos,Data.Data,Data.Size);
/* Compressing If needed */
if(ncchset->Options.CompressCode){
u32 new_len;
ncchset->ExeFs_Sections.Code.buffer = BLZ_Code(code,size,&new_len,BLZ_NORMAL);
ncchset->ExeFs_Sections.Code.size = new_len;
free(code);
}
else{
ncchset->ExeFs_Sections.Code.size = size;
ncchset->ExeFs_Sections.Code.buffer = code;
}
/* Setting CodeSegment Data and freeing original buffers */
ncchset->CodeDetails.TextAddress = Text.Address;
ncchset->CodeDetails.TextMaxPages = Text.MaxPageNum;
ncchset->CodeDetails.TextSize = Text.Size;
if(Text.Size) free(Text.Data);
ncchset->CodeDetails.ROAddress = RO.Address;
ncchset->CodeDetails.ROMaxPages = RO.MaxPageNum;
ncchset->CodeDetails.ROSize = RO.Size;
if(RO.Size) free(RO.Data);
ncchset->CodeDetails.DataAddress = Data.Address;
ncchset->CodeDetails.DataMaxPages = Data.MaxPageNum;
ncchset->CodeDetails.DataSize = Data.Size;
if(Data.Size) free(Data.Data);
/* Return */
return 0;
}
int CreateCodeSegmentFromElf(CodeSegment *out, ElfContext *elf, u8 *ElfFile, char **Names, u32 NameNum)
{
u16 ContinuousSegmentNum = 0;
memset(out,0,sizeof(CodeSegment));
ElfSegment **ContinuousSegments = GetContinuousSegments(&ContinuousSegmentNum,elf,Names,NameNum);
if (ContinuousSegments == NULL){
if(!ContinuousSegmentNum) // Nothing Was Found
return 0;
else // Error with found segments
return ELF_SEGMENTS_NOT_CONTINUOUS;
}
/* Getting Segment Size/Settings */
u32 vAddr = 0;
u32 memorySize = 0;
for(int i = 0; i < ContinuousSegmentNum; i++){
if (i==0){
vAddr = ContinuousSegments[i]->VAddr;
}
else{ // Add rounded size from previous segment
u32 num = ContinuousSegments[i]->VAddr - (vAddr + memorySize);
memorySize += num;
}
memorySize += ContinuousSegments[i]->Header->SizeInMemory;
for (int j = 0; j < ContinuousSegments[i]->SectionNum; j++){
ElfSectionEntry *Section = &ContinuousSegments[i]->Sections[j];
if (IsBss(Section) && j == (ContinuousSegments[i]->SectionNum-1))
memorySize -= Section->Size;
}
}
// For Check
#ifdef ELF_DEBUG
printf("Address: 0x%x\n",vAddr);
printf("Size: 0x%x\n",memorySize);
#endif
out->Address = vAddr;
out->Size = memorySize;
out->MaxPageNum = SizeToPage(memorySize,elf);
out->Data = malloc(memorySize);
/* Writing Segment to Buffer */
vAddr = 0;
memorySize = 0;
for(int i = 0; i < ContinuousSegmentNum; i++){
if (i==0){
vAddr = ContinuousSegments[i]->VAddr;
}
else{
u32 num = ContinuousSegments[i]->VAddr - (vAddr + memorySize);
memorySize += num;
}
u32 size = 0;
for (int j = 0; j < ContinuousSegments[i]->SectionNum; j++){
ElfSectionEntry *Section = &ContinuousSegments[i]->Sections[j];
if (!IsBss(Section)){
u8 *pos = (out->Data + memorySize + size);
memcpy(pos,Section->Ptr,Section->Size);
size += Section->Size;
}
else if (j == (ContinuousSegments[i]->SectionNum-1))
memorySize -= Section->Size;
else
size += Section->Size;
}
}
free(ContinuousSegments);
return 0;
}
ElfSegment** GetContinuousSegments(u16 *ContinuousSegmentNum, ElfContext *elf, char **Names, u32 NameNum)
{
u16 SegmentNum = 0;
ElfSegment **Segments = GetSegments(&SegmentNum, elf, Names, NameNum);
if (Segments == NULL || SegmentNum == 0){ // No Segments for the names were found
//printf("Not Found Segment\n");
return NULL;
}
if (SegmentNum == 1){ //Return as there is no need to check
*ContinuousSegmentNum = SegmentNum;
return Segments;
}
u32 vAddr = Segments[0]->VAddr + Segments[0]->Header->SizeInMemory;
for (int i = 1; i < SegmentNum; i++){
if (Segments[i]->VAddr != (u32)align_value(vAddr,Segments[i]->Header->Alignment)){ //Each Segment must start after each other
fprintf(stderr,"[ELF ERROR] %s segment and %s segment are not continuous\n", Segments[i]->Name, Segments[i - 1]->Name);
free(Segments);
*ContinuousSegmentNum = 0xffff; // Signify to function that an error occured
return NULL;
}
}
*ContinuousSegmentNum = SegmentNum;
return Segments;
}
ElfSegment** GetSegments(u16 *SegmentNum, ElfContext *elf, char **Names, u32 NameNum)
{
if (Names == NULL)
{
return NULL;
}
ElfSegment **Segments = malloc(sizeof(ElfSegment*)*NameNum);
*SegmentNum = 0; // There can be a max of NameNum Segments, however, they might not all exist
for (int i = 0; i < NameNum; i++){
for(int j = 0; j < elf->ActiveSegments; j++){
if(strcmp(Names[i],elf->Segments[j].Name) == 0){ // If there is a match, store Segment data pointer & increment index
Segments[*SegmentNum] = &elf->Segments[j];
*SegmentNum = *SegmentNum + 1;
}
}
}
return Segments;
}
// ELF Functions
int GetElfContext(ElfContext *elf, u8 *ElfFile)
{
if(u8_to_u32(ElfFile,BE) != ELF_MAGIC) return NOT_ELF_FILE;
elf->Is64bit = (ElfFile[4] == elf_64_bit);
elf->IsLittleEndian = (ElfFile[5] == elf_little_endian);
int result = ReadElfHdr(elf,ElfFile);
if(result) return result;
result = GetElfSectionEntries(elf,ElfFile);
if(result) return result;
result = GetElfProgramEntries(elf,ElfFile);
if(result) return result;
result = CreateElfSegments(elf,ElfFile);
if(result) return result;
return 0;
}
int GetElfSectionEntries(ElfContext *elf, u8 *ElfFile)
{
elf->Sections = malloc(sizeof(ElfSectionEntry)*elf->SectionTableEntryCount);
if(!elf->Sections) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
for(int i = 0; i < elf->SectionTableEntryCount; i++){
elf->Sections[i].Name = GetELFSectionEntryName(i,elf,ElfFile);
elf->Sections[i].Type = GetELFSectionEntryType(i,elf,ElfFile);
elf->Sections[i].Flags = GetELFSectionEntryFlags(i,elf,ElfFile);
elf->Sections[i].Ptr = GetELFSectionEntry(i,elf,ElfFile);
elf->Sections[i].OffsetInFile = GetELFSectionEntryFileOffset(i,elf,ElfFile);
elf->Sections[i].Size = GetELFSectionEntrySize(i,elf,ElfFile);
elf->Sections[i].Address = GetELFSectionEntryAddress(i,elf,ElfFile);
elf->Sections[i].Alignment = GetELFSectionEntryAlignment(i,elf,ElfFile);
}
return 0;
}
int GetElfProgramEntries(ElfContext *elf, u8 *ElfFile)
{
elf->ProgramHeaders = malloc(sizeof(ElfProgramEntry)*elf->ProgramTableEntryCount);
if(!elf->ProgramHeaders) {fprintf(stderr,"[ELF ERROR] MEM ERROR\n"); return MEM_ERROR;}
for(int i = 0; i < elf->ProgramTableEntryCount; i++){
elf->ProgramHeaders[i].Type = GetELFProgramEntryType(i,elf,ElfFile);
elf->ProgramHeaders[i].Flags = GetELFProgramEntryFlags(i,elf,ElfFile);
elf->ProgramHeaders[i].Ptr = GetELFProgramEntry(i,elf,ElfFile);
elf->ProgramHeaders[i].OffsetInFile = GetELFProgramEntryFileOffset(i,elf,ElfFile);
elf->ProgramHeaders[i].SizeInFile = GetELFProgramEntryFileSize(i,elf,ElfFile);
elf->ProgramHeaders[i].PhysicalAddress = GetELFProgramEntryPAddress(i,elf,ElfFile);
elf->ProgramHeaders[i].VirtualAddress = GetELFProgramEntryVAddress(i,elf,ElfFile);
elf->ProgramHeaders[i].SizeInMemory = GetELFProgramEntryMemorySize(i,elf,ElfFile);
elf->ProgramHeaders[i].Alignment = GetELFProgramEntryAlignment(i,elf,ElfFile);
}
return 0;
}
void PrintElfContext(ElfContext *elf, u8 *ElfFile)
{
printf("[+] Basic Details\n");
printf(" Class: %s\n",elf->Is64bit ? "64-bit" : "32-bit");
printf(" Data: %s\n",elf->IsLittleEndian ? "Little Endian" : "Big Endian");
printf("\n[+] Program Table Data\n");
printf(" Offset: 0x%lx\n",elf->ProgramTableOffset);
printf(" Size: 0x%x\n",elf->ProgramTableEntrySize);
printf(" Count: 0x%x\n",elf->ProgramTableEntryCount);
printf("\n[+] Section Table Data\n");
printf(" Offset: 0x%lx\n",elf->SectionTableOffset);
printf(" Size: 0x%x\n",elf->SectionTableEntrySize);
printf(" Count: 0x%x\n",elf->SectionTableEntryCount);
printf(" Lable Index: 0x%x\n",elf->SectionHeaderNameEntryIndex);
for(int i = 0; i < elf->ActiveSegments; i++){
printf(" Segment [%d][%s]\n",i,elf->Segments[i].Name);
printf(" > Size : 0x%x\n",elf->Segments[i].Header->SizeInFile);
printf(" > Address : 0x%x\n",elf->Segments[i].VAddr);
printf(" > Sections : %d\n",elf->Segments[i].SectionNum);
for(int j = 0; j < elf->Segments[i].SectionNum; j++){
printf(" > Section [%d][%s]\n",j,elf->Segments[i].Sections[j].Name);
}
/*
char outpath[100];
memset(&outpath,0,100);
sprintf(outpath,"%s.bin",elf->Sections[i].Name);
chdir("elfsections");
FILE *tmp = fopen(outpath,"wb");
WriteBuffer(elf->Sections[i].Ptr,elf->Sections[i].Size,0,tmp);
fclose(tmp);
chdir("..");
*/
}
}
int ReadElfHdr(ElfContext *elf, u8 *ElfFile)
{
if(elf->Is64bit){
elf_64_hdr *hdr = (elf_64_hdr*)ElfFile;
u16 Architecture = u8_to_u16(hdr->TargetArchitecture,elf->IsLittleEndian);
u16 Type = u8_to_u16(hdr->Type,elf->IsLittleEndian);
if(Architecture != elf_arm) return NOT_ARM_ELF;
if(Type != elf_executeable) return NON_EXECUTABLE_ELF;
elf->ProgramTableOffset = u8_to_u64(hdr->ProgramHeaderTableOffset,elf->IsLittleEndian);
elf->ProgramTableEntrySize = u8_to_u16(hdr->ProgramHeaderEntrySize,elf->IsLittleEndian);
elf->ProgramTableEntryCount = u8_to_u16(hdr->ProgramHeaderEntryCount,elf->IsLittleEndian);
elf->SectionTableOffset = u8_to_u64(hdr->SectionHeaderTableOffset,elf->IsLittleEndian);
elf->SectionTableEntrySize = u8_to_u16(hdr->SectionTableEntrySize,elf->IsLittleEndian);
elf->SectionTableEntryCount = u8_to_u16(hdr->SectionHeaderEntryCount,elf->IsLittleEndian);
elf->SectionHeaderNameEntryIndex = u8_to_u16(hdr->SectionHeaderNameEntryIndex,elf->IsLittleEndian);
}
else{
elf_32_hdr *hdr = (elf_32_hdr*)ElfFile;
u16 Architecture = u8_to_u16(hdr->TargetArchitecture,elf->IsLittleEndian);
u16 Type = u8_to_u16(hdr->Type,elf->IsLittleEndian);
if(Architecture != elf_arm) return NOT_ARM_ELF;
if(Type != elf_executeable) return NON_EXECUTABLE_ELF;
elf->ProgramTableOffset = u8_to_u32(hdr->ProgramHeaderTableOffset,elf->IsLittleEndian);
elf->ProgramTableEntrySize = u8_to_u16(hdr->ProgramHeaderEntrySize,elf->IsLittleEndian);
elf->ProgramTableEntryCount = u8_to_u16(hdr->ProgramHeaderEntryCount,elf->IsLittleEndian);
elf->SectionTableOffset = u8_to_u32(hdr->SectionHeaderTableOffset,elf->IsLittleEndian);
elf->SectionTableEntrySize = u8_to_u16(hdr->SectionTableEntrySize,elf->IsLittleEndian);
elf->SectionTableEntryCount = u8_to_u16(hdr->SectionHeaderEntryCount,elf->IsLittleEndian);
elf->SectionHeaderNameEntryIndex = u8_to_u16(hdr->SectionHeaderNameEntryIndex,elf->IsLittleEndian);
}
return 0;
}
/* Section Hdr Functions */
u8* GetELFSectionHeader(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return NULL;
return (ElfFile + elf->SectionTableOffset + elf->SectionTableEntrySize*Index);
}
u8* GetELFSectionEntry(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return NULL;
return (u8*) (ElfFile + GetELFSectionEntryFileOffset(Index,elf,ElfFile));
}
char* GetELFSectionEntryName(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
u64 NameIndex = 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
NameIndex = u8_to_u64(shdr->sh_name,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
NameIndex = u8_to_u32(shdr->sh_name,elf->IsLittleEndian);
}
u8 *NameTable = GetELFSectionEntry(elf->SectionHeaderNameEntryIndex,elf,ElfFile);
return (char*)(NameTable+NameIndex);
}
u64 GetELFSectionEntryType(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_type,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_type,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFSectionEntryFlags(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_flags,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_flags,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFSectionEntryAddress(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_addr,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_addr,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFSectionEntryFileOffset(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_offset,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_offset,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFSectionEntrySize(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_size,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_size,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFSectionEntryAlignment(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->SectionTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_shdr *shdr = (elf_64_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u64(shdr->sh_addralign,elf->IsLittleEndian);
}
else{
elf_32_shdr *shdr = (elf_32_shdr*)GetELFSectionHeader(Index,elf,ElfFile);
return u8_to_u32(shdr->sh_addralign,elf->IsLittleEndian);
}
return 0;
}
u16 GetElfSectionIndexFromName(char *Name, ElfContext *elf, u8 *ElfFile)
{
for(int i = 0; i < elf->SectionTableEntryCount; i++){
if(strcmp(Name,elf->Sections[i].Name) == 0) return i;
}
return 0; // Assuming 0 is always empty
}
bool IsBss(ElfSectionEntry *Section)
{
if(Section->Type == 8 && Section->Flags == 3)
return true;
return false;
}
bool IsData(ElfSectionEntry *Section)
{
if(Section->Type == 1 && Section->Flags == 3)
return true;
return false;
}
bool IsRO(ElfSectionEntry *Section)
{
if(Section->Type == 1 && Section->Flags == 2)
return true;
return false;
}
bool IsText(ElfSectionEntry *Section)
{
if(Section->Type == 1 && Section->Flags == 6)
return true;
return false;
}
/* ProgramHeader Functions */
u8* GetELFProgramHeader(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return NULL;
return (ElfFile + elf->ProgramTableOffset + elf->ProgramTableEntrySize*Index);
}
u8* GetELFProgramEntry(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return NULL;
return (u8*) (ElfFile + GetELFProgramEntryFileOffset(Index,elf,ElfFile));
return NULL;
}
u64 GetELFProgramEntryType(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_type,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_type,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryFlags(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_flags,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_flags,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryFileSize(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_filesz,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_filesz,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryFileOffset(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_offset,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_offset,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryMemorySize(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_memsz,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_memsz,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryVAddress(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_vaddr,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_vaddr,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryPAddress(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_paddr,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_paddr,elf->IsLittleEndian);
}
return 0;
}
u64 GetELFProgramEntryAlignment(u16 Index, ElfContext *elf, u8 *ElfFile)
{
if(Index >= elf->ProgramTableEntryCount) return 0;
if(elf->Is64bit){
elf_64_phdr *phdr = (elf_64_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u64(phdr->p_align,elf->IsLittleEndian);
}
else{
elf_32_phdr *phdr = (elf_32_phdr*)GetELFProgramHeader(Index,elf,ElfFile);
return u8_to_u32(phdr->p_align,elf->IsLittleEndian);
}
return 0;
}
int CreateElfSegments(ElfContext *elf, u8 *ElfFile)
{
int num = 0;
// Interate through Each Program Header
elf->ActiveSegments = 0;
elf->Segments = malloc(sizeof(ElfSegment)*elf->ProgramTableEntryCount);
ElfSegment *segment = malloc(sizeof(ElfSegment)); // Temporary Buffer
for (int i = 0; i < elf->ProgramTableEntryCount; i++){
if (elf->ProgramHeaders[i].SizeInMemory != 0 && elf->ProgramHeaders[i].Type == 1){
memset(segment,0,sizeof(ElfSegment));
bool flag = false;
u32 size = 0;
u32 vAddr = elf->ProgramHeaders[i].VirtualAddress;
u32 memorySize = elf->ProgramHeaders[i].SizeInMemory;
u16 SectionInfoCapacity = 10;
segment->SectionNum = 0;
segment->Sections = malloc(sizeof(ElfSectionEntry)*SectionInfoCapacity);
// Itterate Through Section Headers
for (int j = num; j < elf->SectionTableEntryCount; j++){
if (!flag){
if (elf->Sections[j].Address != vAddr)
goto Skip;
while (j < (int)elf->Sections[j].Size && elf->Sections[j].Address == vAddr && !IsIgnoreSection(elf->Sections[j]))
j++;
j--;
flag = true;
segment->VAddr = elf->Sections[j].Address;
segment->Name = elf->Sections[j].Name;
}
if(segment->SectionNum < SectionInfoCapacity)
memcpy(&segment->Sections[segment->SectionNum],&elf->Sections[j],sizeof(ElfSectionEntry));
else{
SectionInfoCapacity = SectionInfoCapacity*2;
ElfSectionEntry *tmp = malloc(sizeof(ElfSectionEntry)*SectionInfoCapacity);
for(int k = 0; k < segment->SectionNum; k++)
memcpy(&tmp[k],&segment->Sections[k],sizeof(ElfSectionEntry));
free(segment->Sections);
segment->Sections = tmp;
memcpy(&segment->Sections[segment->SectionNum],&elf->Sections[j],sizeof(ElfSectionEntry));
}
segment->SectionNum++;
size += elf->Sections[j].Size;
if (size == memorySize)
break;
if (size > memorySize){
fprintf(stderr,"[ELF ERROR] Too large section size.\n Segment size = 0x%x\n Section Size = 0x%x\n", memorySize, size);
return ELF_SEGMENT_SECTION_SIZE_MISMATCH;
}
Skip: ;
}
if(segment->SectionNum){
segment->Header = &elf->ProgramHeaders[i];
memcpy(&elf->Segments[elf->ActiveSegments],segment,sizeof(ElfSegment));
elf->ActiveSegments++;
}
else{
free(segment->Sections);
free(segment);
fprintf(stderr,"[ELF ERROR] Program Header Has no corresponding Sections, ELF Cannot be proccessed\n");
return ELF_SEGMENTS_NOT_FOUND;
}
}
}
free(segment);
return 0;
}
bool IsIgnoreSection(ElfSectionEntry info)
{
if (info.Address)
return false;
if (info.Type != 1 && info.Type != 0)
return true;
char IgnoreSectionNames[7][20] = { ".debug_abbrev", ".debug_frame", ".debug_info", ".debug_line", ".debug_loc", ".debug_pubnames", ".comment" };
for (int i = 0; i < 7; i++){
if (strcmp(IgnoreSectionNames[i],info.Name) == 0)
return true;
}
return false;
}
elf.h
-87
View File
@@ -1,87 +0,0 @@
#ifndef _ELF_H_
#define _ELF_H_
typedef enum
{
NOT_ELF_FILE = -10,
NOT_ARM_ELF = -11,
NON_EXECUTABLE_ELF = -12,
ELF_SECTION_NOT_FOUND = -13,
NOT_FIND_BSS_SIZE = -14,
NOT_FIND_CODE_SECTIONS = -15,
ELF_SEGMENT_SECTION_SIZE_MISMATCH = -16,
ELF_SEGMENTS_NOT_CONTINUOUS = -17,
ELF_SEGMENTS_NOT_FOUND = -18,
} elf_errors;
typedef struct
{
char *Name;
u64 Type;
u64 Flags;
u8 *Ptr;
u64 OffsetInFile;
u64 Size;
u64 Address;
u64 Alignment;
} ElfSectionEntry;
typedef struct
{
u64 Type;
u64 Flags;
u8 *Ptr;
u64 OffsetInFile;
u64 SizeInFile;
u64 VirtualAddress;
u64 PhysicalAddress;
u64 SizeInMemory;
u64 Alignment;
} ElfProgramEntry;
typedef struct
{
char *Name;
u64 VAddr;
ElfProgramEntry *Header;
u32 SectionNum;
ElfSectionEntry *Sections;
} ElfSegment;
typedef struct
{
u32 Address;
u32 Size;
u32 MaxPageNum;
u8 *Data;
} CodeSegment;
typedef struct
{
u32 PageSize;
bool IsLittleEndian;
bool Is64bit;
u64 ProgramTableOffset;
u16 ProgramTableEntrySize;
u16 ProgramTableEntryCount;
u64 SectionTableOffset;
u16 SectionTableEntrySize;
u16 SectionTableEntryCount;
u16 SectionHeaderNameEntryIndex;
ElfSectionEntry *Sections;
ElfProgramEntry *ProgramHeaders;
u16 ActiveSegments;
ElfSegment *Segments;
} ElfContext;
#endif
int BuildExeFsCode(ncch_settings *ncchset);
elf_hdr.h
-177
View File
@@ -1,177 +0,0 @@
#ifndef _ELF_HDR_H_
#define _ELF_HDR_H_
static const u32 ELF_MAGIC = 0x7f454c46;
typedef enum
{
elf_32_bit = 1,
elf_64_bit = 2,
} elf_bit_format_types;
typedef enum
{
elf_little_endian = 1,
elf_big_endian = 2,
} elf_endianness;
typedef enum
{
elf_relocatable = 1,
elf_executeable = 2,
elf_shared = 3,
elf_core = 4,
} elf_type;
typedef enum
{
elf_arm = 0x28,
} elf_target_architecture;
typedef struct
{
u8 Magic[4];
u8 BitFormat;
u8 Endianness;
u8 ELF_Version;
u8 OS;
u8 Padding_0[8];
u8 Type[2];
u8 TargetArchitecture[2];
u8 Version[4];
u8 EntryPoint[4];
u8 ProgramHeaderTableOffset[4];
u8 SectionHeaderTableOffset[4];
u8 Flags[4];
u8 HeaderSize[2];
u8 ProgramHeaderEntrySize[2];
u8 ProgramHeaderEntryCount[2];
u8 SectionTableEntrySize[2];
u8 SectionHeaderEntryCount[2];
u8 SectionHeaderNameEntryIndex[2];
} elf_32_hdr;
typedef struct
{
u8 Magic[4];
u8 BitFormat;
u8 Endianness;
u8 ELF_Version;
u8 OS;
u8 Padding_0[8];
u8 Type[2];
u8 TargetArchitecture[2];
u8 Version[4];
u8 EntryPoint[8];
u8 ProgramHeaderTableOffset[8];
u8 SectionHeaderTableOffset[8];
u8 Flags[4];
u8 HeaderSize[2];
u8 ProgramHeaderEntrySize[2];
u8 ProgramHeaderEntryCount[2];
u8 SectionTableEntrySize[2];
u8 SectionHeaderEntryCount[2];
u8 SectionHeaderNameEntryIndex[2];
} elf_64_hdr;
/* Section header. */
/* Legal values for sh_type (section type). */
#define SHT_NULL 0 /* Section header table entry unused */
#define SHT_PROGBITS 1 /* Program data */
#define SHT_SYMTAB 2 /* Symbol table */
#define SHT_STRTAB 3 /* String table */
#define SHT_RELA 4 /* Relocation entries with addends */
#define SHT_HASH 5 /* Symbol hash table */
#define SHT_DYNAMIC 6 /* Dynamic linking information */
#define SHT_NOTE 7 /* Notes */
#define SHT_NOBITS 8 /* Program space with no data (bss) */
#define SHT_REL 9 /* Relocation entries, no addends */
#define SHT_SHLIB 10 /* Reserved */
#define SHT_DYNSYM 11 /* Dynamic linker symbol table */
#define SHT_NUM 12 /* Number of defined types. */
#define SHT_LOOS 0x60000000 /* Start OS-specific */
#define SHT_LOSUNW 0x6ffffffb /* Sun-specific low bound. */
#define SHT_SUNW_COMDAT 0x6ffffffb
#define SHT_SUNW_syminfo 0x6ffffffc
#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */
#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */
#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */
#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */
#define SHT_HIOS 0x6fffffff /* End OS-specific type */
#define SHT_LOPROC 0x70000000 /* Start of processor-specific */
#define SHT_HIPROC 0x7fffffff /* End of processor-specific */
#define SHT_LOUSER 0x80000000 /* Start of application-specific */
#define SHT_HIUSER 0x8fffffff /* End of application-specific */
typedef struct
{
u8 sh_name[4]; /* Section name (string tbl index) */
u8 sh_type[4]; /* Section type */
u8 sh_flags[4]; /* Section flags */
u8 sh_addr[4]; /* Section virtual addr at execution */
u8 sh_offset[4]; /* Section file offset */
u8 sh_size[4]; /* Section size in bytes */
u8 sh_link[4]; /* Link to another section */
u8 sh_info[4]; /* Additional section information */
u8 sh_addralign[4]; /* Section alignment */
u8 sh_entsize[4]; /* Entry size if section holds table */
} elf_32_shdr;
typedef struct
{
u8 sh_name[8]; /* Section name (string tbl index) */
u8 sh_type[8]; /* Section type */
u8 sh_flags[8]; /* Section flags */
u8 sh_addr[8]; /* Section virtual addr at execution */
u8 sh_offset[8]; /* Section file offset */
u8 sh_size[8]; /* Section size in bytes */
u8 sh_link[8]; /* Link to another section */
u8 sh_info[8]; /* Additional section information */
u8 sh_addralign[8]; /* Section alignment */
u8 sh_entsize[8]; /* Entry size if section holds table */
} elf_64_shdr;
/* Program segment header. */
/* p_type legal values */
#define PT_NULL 0 /* Program header table entry unused */
#define PT_LOAD 1 /* Loadable program segment */
#define PT_DYNAMIC 2 /* Dynamic linking information */
#define PT_INTERP 3 /* Program interpreter */
#define PT_NOTE 4 /* Auxiliary information */
#define PT_SHLIB 5 /* Reserved */
#define PT_PHDR 6 /* Entry for header table itself */
#define PT_NUM 7 /* Number of defined types. */
#define PT_LOOS 0x60000000 /* Start of OS-specific */
#define PT_HIOS 0x6fffffff /* End of OS-specific */
#define PT_LOPROC 0x70000000 /* Start of processor-specific */
#define PT_HIPROC 0x7fffffff /* End of processor-specific */
typedef struct
{
u8 p_type[4]; /* Segment type */
u8 p_offset[4]; /* Segment file offset */
u8 p_vaddr[4]; /* Segment virtual address */
u8 p_paddr[4]; /* Segment physical address */
u8 p_filesz[4]; /* Segment size in file */
u8 p_memsz[4]; /* Segment size in memory */
u8 p_flags[4]; /* Segment flags */
u8 p_align[4]; /* Segment alignment */
} elf_32_phdr;
typedef struct
{
u8 p_type[8]; /* Segment type */
u8 p_flags[8]; /* Segment flags */
u8 p_offset[8]; /* Segment file offset */
u8 p_vaddr[8]; /* Segment virtual address */
u8 p_paddr[8]; /* Segment physical address */
u8 p_filesz[8]; /* Segment size in file */
u8 p_memsz[8]; /* Segment size in memory */
u8 p_align[8]; /* Segment alignment */
} elf_64_phdr;
#endif
exefs.c
-179
View File
@@ -1,179 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "exefs.h"
// Private Prototypes
u32 PredictExeFS_Size(ExeFs_BuildContext *ctx);
int GenerateExeFS_Header(ExeFs_BuildContext *ctx, u8 *outbuff);
void InitialiseExeFSContext(ExeFs_BuildContext *ctx);
void FreeExeFSContext(ExeFs_BuildContext *ctx);
int ImportDatatoExeFS(ExeFs_BuildContext *ctx, u8 *outbuff);
int ImportToExeFSContext(ExeFs_BuildContext *ctx, char *lable, u8 *buffer, u32 size);
// ExeFs Build Functions
int BuildExeFs(ncch_settings *ncchset)
{
/* Intialising ExeFs Build Context */
ExeFs_BuildContext *ctx = malloc(sizeof(ExeFs_BuildContext));
if(!ctx) {fprintf(stderr,"[EXEFS ERROR] MEM ERROR\n"); return MEM_ERROR;}
InitialiseExeFSContext(ctx);
ctx->media_unit = ncchset->Options.MediaSize;
/* Importing ExeFs */
if(ncchset->ExeFs_Sections.Code.size)
ImportToExeFSContext(ctx,".code",ncchset->ExeFs_Sections.Code.buffer,ncchset->ExeFs_Sections.Code.size);
if(ncchset->ExeFs_Sections.Banner.size)
ImportToExeFSContext(ctx,"banner",ncchset->ExeFs_Sections.Banner.buffer,ncchset->ExeFs_Sections.Banner.size);
if(ncchset->ExeFs_Sections.Icon.size)
ImportToExeFSContext(ctx,"icon",ncchset->ExeFs_Sections.Icon.buffer,ncchset->ExeFs_Sections.Icon.size);
if(ncchset->Sections.Logo.size && ncchset->Options.IncludeExeFsLogo)
ImportToExeFSContext(ctx,"logo",ncchset->Sections.Logo.buffer,ncchset->Sections.Logo.size);
/* Allocating Memory for ExeFs */
ncchset->Sections.ExeFs.size = PredictExeFS_Size(ctx);
ncchset->Sections.ExeFs.buffer = malloc(ncchset->Sections.ExeFs.size);
if(!ncchset->Sections.ExeFs.buffer){
printf("[EXEFS ERROR] Could Not Allocate Memory for ExeFS\n");
return Fail;
}
memset(ncchset->Sections.ExeFs.buffer,0,ncchset->Sections.ExeFs.size);
/* Generating Header, and writing sections to buffer */
GenerateExeFS_Header(ctx,ncchset->Sections.ExeFs.buffer);
ImportDatatoExeFS(ctx,ncchset->Sections.ExeFs.buffer);
/* Finish */
FreeExeFSContext(ctx);
return 0;
}
u32 PredictExeFS_Size(ExeFs_BuildContext *ctx)
{
u32 exefs_size = 0x200; // Size of header
for(int i = 0; i < ctx->section_count; i++){
exefs_size += align_value(ctx->section_size[i],ctx->media_unit);
}
//exefs_size = align_value(ctx->exefs_size,ctx->media_unit);
return exefs_size;
}
int GenerateExeFS_Header(ExeFs_BuildContext *ctx, u8 *outbuff)
{
for(int i = 0; i < ctx->section_count; i++){
if(i == 0)
ctx->section_offset[i] = 0;
else
ctx->section_offset[i] = align_value((ctx->section_offset[i-1]+ctx->section_size[i-1]),ctx->media_unit);
memcpy(ctx->file_header[i].name,ctx->lable[i],8);
u32_to_u8(ctx->file_header[i].offset,ctx->section_offset[i],LE);
u32_to_u8(ctx->file_header[i].size,ctx->section_size[i],LE);
ctr_sha(ctx->section[i],ctx->section_size[i],ctx->file_hashes[9-i],CTR_SHA_256);
}
memcpy(outbuff,ctx->file_header,sizeof(ExeFs_FileHeader)*10);
memcpy(outbuff+0xc0,ctx->file_hashes,0x20*10);
return 0;
}
void InitialiseExeFSContext(ExeFs_BuildContext *ctx)
{
memset(ctx,0,sizeof(ExeFs_BuildContext));
}
void FreeExeFSContext(ExeFs_BuildContext *ctx)
{
/*
if(ctx->outbuff != NULL)
free(ctx->outbuff);
for(int i = 0; i < 10; i++){
if(ctx->section[i] != NULL)
free(ctx->section[i]);
}
*/
memset(ctx,0,sizeof(ExeFs_BuildContext));
free(ctx);
}
int ImportDatatoExeFS(ExeFs_BuildContext *ctx, u8 *outbuff)
{
for(int i = 0; i < ctx->section_count; i++){
memcpy(outbuff+ctx->section_offset[i]+0x200,ctx->section[i],ctx->section_size[i]);
}
return 0;
}
int ImportToExeFSContext(ExeFs_BuildContext *ctx, char *lable, u8 *buffer, u32 size)
{
if(ctx == NULL || lable == NULL || buffer == NULL){
printf("[!] PTR ERROR\n");
return PTR_ERROR;
}
if(ctx->section_count >= 10){
printf("[!] Maximum ExeFS Capacity Reached\n");
return EXEFS_MAX_REACHED;
}
if(strlen(lable) > 8){
printf("[!] ExeFS Section Name: '%s' is too large\n",lable);
return EXEFS_SECTION_NAME_ERROR;
}
ctx->section_count++;
ctx->section[ctx->section_count - 1] = buffer;
ctx->section_size[ctx->section_count - 1] = size;
strcpy(ctx->lable[ctx->section_count - 1],lable);
return 0;
}
// ExeFs Read Functions
bool DoesExeFsSectionExist(char *section, u8 *ExeFs)
{
ExeFs_Header *hdr = (ExeFs_Header*) ExeFs;
for(int i = 0; i < MAX_EXEFS_SECTIONS; i++){
if(strncmp(hdr->SectionHdr[i].name,section,8) == 0) return true;
}
return false;
}
u8* GetExeFsSection(char *section, u8 *ExeFs)
{
ExeFs_Header *hdr = (ExeFs_Header*) ExeFs;
for(int i = 0; i < MAX_EXEFS_SECTIONS; i++){
if(strncmp(hdr->SectionHdr[i].name,section,8) == 0){
u32 offset = u8_to_u32(hdr->SectionHdr[i].offset,LE) + sizeof(ExeFs_Header);
return (u8*)(ExeFs+offset);
}
}
return NULL;
}
u8* GetExeFsSectionHash(char *section, u8 *ExeFs)
{
ExeFs_Header *hdr = (ExeFs_Header*) ExeFs;
for(int i = 0; i < MAX_EXEFS_SECTIONS; i++){
if(strncmp(hdr->SectionHdr[i].name,section,8) == 0){
return (u8*)(hdr->SectionHashes[MAX_EXEFS_SECTIONS-1-i]);
}
}
return NULL;
}
u32 GetExeFsSectionSize(char *section, u8 *ExeFs)
{
ExeFs_Header *hdr = (ExeFs_Header*) ExeFs;
for(int i = 0; i < MAX_EXEFS_SECTIONS; i++){
if(strncmp(hdr->SectionHdr[i].name,section,8) == 0){
return u8_to_u32(hdr->SectionHdr[i].size,LE);
}
}
return 0;
}
u32 GetExeFsSectionOffset(char *section, u8 *ExeFs)
{
ExeFs_Header *hdr = (ExeFs_Header*) ExeFs;
for(int i = 0; i < MAX_EXEFS_SECTIONS; i++){
if(strncmp(hdr->SectionHdr[i].name,section,8) == 0){
return u8_to_u32(hdr->SectionHdr[i].offset,LE) + sizeof(ExeFs_Header);
}
}
return 0;
}
exefs.h
-54
View File
@@ -1,54 +0,0 @@
#ifndef _EXEFS_H_
#define _EXEFS_H_
#define MAX_EXEFS_SECTIONS 10 // DO NOT CHANGE
typedef enum
{
PTR_ERROR = -10,
EXEFS_MAX_REACHED = -11,
EXEFS_SECTION_NAME_ERROR = -12,
} exefs_errors;
typedef struct
{
char name[8];
u8 offset[4];
u8 size[4];
} ExeFs_FileHeader;
typedef struct
{
//Input
int section_count;
u8 *section[10];
u32 section_size[10];
u32 section_offset[10];
char lable[10][8];
u32 media_unit;
//Working Data
ExeFs_FileHeader file_header[10];
u8 file_hashes[10][0x20];
} ExeFs_BuildContext;
typedef struct
{
ExeFs_FileHeader SectionHdr[MAX_EXEFS_SECTIONS];
u8 Reserved[0x20];
u8 SectionHashes[MAX_EXEFS_SECTIONS][0x20];
} ExeFs_Header;
#endif
/* ExeFs Build Functions */
int BuildExeFs(ncch_settings *ncchset);
/* ExeFs Read Functions */
bool DoesExeFsSectionExist(char *section, u8 *ExeFs);
u8* GetExeFsSection(char *section, u8 *ExeFs);
u8* GetExeFsSectionHash(char *section, u8 *ExeFs);
u32 GetExeFsSectionSize(char *section, u8 *ExeFs);
u32 GetExeFsSectionOffset(char *section, u8 *ExeFs);
exheader.c
-1522
View File
File diff suppressed because it is too large Load Diff
exheader.h
-233
View File
@@ -1,233 +0,0 @@
#ifndef _EXHEADER_H_
#define _EXHEADER_H_
typedef enum
{
COMMON_HEADER_KEY_NOT_FOUND = -10,
EXHDR_BAD_YAML_OPT = -11,
CANNOT_SIGN_ACCESSDESC = -12
} exheader_errors;
typedef enum
{
ExeFsCodeCompress = 1,
RetailSDAppFlag = 2,
} SystemInfoFlags_Flagbitmask;
typedef enum
{
memtype_APPLICATION = 1,
memtype_SYSTEM = 2,
memtype_BASE = 3
} MemoryTypeName;
typedef enum
{
processtype_DEFAULT = -1,
processtype_SYSTEM = 0,
processtype_APPLICATION = 1
} ProcessTypeName;
typedef enum
{
resrc_limit_APPLICATION,
resrc_limit_SYS_APPLET,
resrc_limit_LIB_APPLET,
resrc_limit_OTHER
} ResourceLimitCategoryName;
typedef enum
{
othcap_PERMIT_DEBUG,
othcap_FORCE_DEBUG,
othcap_CAN_USE_NON_ALPHABET_AND_NUMBER,
othcap_CAN_WRITE_SHARED_PAGE,
othcap_CAN_USE_PRIVILEGE_PRIORITY,
othcap_PERMIT_MAIN_FUNCTION_ARGUMENT,
othcap_CAN_SHARE_DEVICE_MEMORY,
othcap_RUNNABLE_ON_SLEEP,
othcap_SPECIAL_MEMORY_ARRANGE = 12,
} OtherCapabilities_Flagbitmask;
typedef enum
{
fsaccess_CATEGORY_SYSTEM_APPLICATION,
fsaccess_CATEGORY_HARDWARE_CHECK,
fsaccess_CATEGORY_FILE_SYSTEM_TOOL,
fsaccess_DEBUG,
fsaccess_TWL_CARD_BACKUP,
fsaccess_TWL_NAND_DATA,
fsaccess_BOSS,
fsaccess_DIRECT_SDMC,
fsaccess_CORE,
fsaccess_CTR_NAND_RO,
fsaccess_CTR_NAND_RW,
fsaccess_CTR_NAND_RO_WRITE,
fsaccess_CATEGORY_SYSTEM_SETTINGS,
fsaccess_CARD_BOARD,
fsaccess_EXPORT_IMPORT_IVS,
fsaccess_DIRECT_SDMC_WRITE,
fsaccess_SWITCH_CLEANUP,
fsaccess_SAVE_DATA_MOVE,
fsaccess_SHOP,
fsaccess_SHELL,
fsaccess_CATEGORY_HOME_MENU
} FileSystemAccess;
typedef enum
{
attribute_NOT_USE_ROMFS,
attribute_USE_EXTENDED_SAVEDATA_ACCESS_CONTROL
} AttributeName;
typedef enum
{
arm9cap_FS_MOUNT_NAND,
arm9cap_FS_MOUNT_NAND_RO_WRITE,
arm9cap_FS_MOUNT_TWLN,
arm9cap_FS_MOUNT_WNAND,
arm9cap_FS_MOUNT_CARD_SPI,
arm9cap_USE_SDIF3,
arm9cap_CREATE_SEED,
arm9cap_USE_CARD_SPI,
arm9cap_SD_APPLICATION,
arm9cap_USE_DIRECT_SDMC
} Arm9Capability;
typedef struct
{
u8 reserved[5];
u8 flag;
u8 remasterVersion[2]; // le u16
} exhdr_SystemInfoFlags;
typedef struct
{
u8 Address[4]; // le u32
u8 NumMaxPages[4]; // le u32
u8 CodeSize[4]; // le u32
} exhdr_CodeSegmentInfo;
typedef struct
{
u8 Name[8];
exhdr_SystemInfoFlags Flags;
exhdr_CodeSegmentInfo TextSectionInfo;
u8 StackSize[4]; // le u32
exhdr_CodeSegmentInfo ReadOnlySectionInfo;
u8 Reserved[4];
exhdr_CodeSegmentInfo DataSectionInfo;
u8 BssSize[4]; // le u32
} exhdr_CodeSetInfo;
typedef struct
{
u8 SaveDataSize[8];
u8 JumpId[8];
u8 Reserved[0x30];
} exhdr_SystemInfo;
typedef struct
{
u8 ExtSaveDataId[8];
u8 SystemSaveDataId[8];
u8 StorageAccessableUniqueIds[8];
u8 AccessInfo[7];
u8 OtherAttributes;
} exhdr_StorageInfo;
typedef struct
{
u8 ProgramId[8];
u8 Flags[8];
u8 ResourceLimitDescriptor[16][2];
exhdr_StorageInfo StorageInfo;
u8 ServiceAccessControl[32][8]; // Those char[8] svc handles
u8 Reserved1[0x1f];
u8 ResourceLimitCategory;
} exhdr_ARM11SystemLocalCapabilities;
typedef struct
{
u16 num;
u32 *Data;
} ARM11KernelCapabilityDescriptor;
typedef enum
{
desc_InteruptNumList = 0xe0000000,
desc_SysCallControl = 0xf0000000,
desc_KernelReleaseVersion = 0xfc000000,
desc_HandleTableSize = 0xfe000000,
desc_OtherCapabilities = 0xff000000,
desc_MappingStatic = 0xff800000,
desc_MappingIO = 0xffc00000,
} ARM11KernelCapabilityDescriptorBitmask;
typedef struct
{
u8 descriptors[28][4];// Descripters are a collection of u32s, with bitmask idents so they can be identified, 'no matter the pos'
u8 reserved[0x10];
} exhdr_ARM11KernelCapabilities;
typedef struct
{
u8 descriptors[16]; //descriptors[15] = DescVersion
} exhdr_ARM9AccessControlInfo;
typedef struct
{
// systemcontrol info {
// coreinfo {
exhdr_CodeSetInfo CodeSetInfo;
u8 DependencyList[0x30][8];
// }
exhdr_SystemInfo SystemInfo;
// }
// accesscontrolinfo {
exhdr_ARM11SystemLocalCapabilities ARM11SystemLocalCapabilities;
exhdr_ARM11KernelCapabilities ARM11KernelCapabilities;
exhdr_ARM9AccessControlInfo ARM9AccessControlInfo;
// }
struct {
u8 signature[0x100];
u8 ncchpubkeymodulus[0x100];
exhdr_ARM11SystemLocalCapabilities ARM11SystemLocalCapabilities;
exhdr_ARM11KernelCapabilities ARM11KernelCapabilities;
exhdr_ARM9AccessControlInfo ARM9AccessControlInfo;
} AccessDescriptor;
} ExtendedHeader_Struct;
typedef struct
{
keys_struct *keys;
rsf_settings *yaml;
bool UseAccessDescPreset;
/* Output */
ExtendedHeader_Struct *ExHdr; // is the exheader output buffer ptr(in ncchset) cast as exheader struct ptr;
} exheader_settings;
#endif
/* ExHeader Signature Functions */
int SignAccessDesc(ExtendedHeader_Struct *ExHdr, keys_struct *keys);
int CheckAccessDescSignature(ExtendedHeader_Struct *ExHdr, keys_struct *keys);
/* ExHeader Build Functions */
int BuildExHeader(ncch_settings *ncchset);
/* ExHeader Binary Print Functions */
void exhdr_Print_ServiceAccessControl(ExtendedHeader_Struct *hdr);
/* ExHeader Binary Read Functions */
u8* GetAccessDescSig_frm_exhdr(ExtendedHeader_Struct *hdr);
u8* GetNcchHdrPubKey_frm_exhdr(ExtendedHeader_Struct *hdr);
u8* GetAccessDesc_frm_exhdr(ExtendedHeader_Struct *hdr);
u16 GetRemasterVersion_frm_exhdr(ExtendedHeader_Struct *hdr);
u64 GetSaveDataSize_frm_exhdr(ExtendedHeader_Struct *hdr);
int GetDependancyList_frm_exhdr(u8 *Dest,ExtendedHeader_Struct *hdr);
int GetCoreVersion_frm_exhdr(u8 *Dest, ExtendedHeader_Struct *hdr);
/* ExHeader Settings Read from Yaml */
int GetSaveDataSize_yaml(u64 *SaveDataSize, user_settings *usrset);
int GetRemasterVersion_yaml(u16 *RemasterVersion, user_settings *usrset);
keys_common.h
-83
View File
@@ -1,83 +0,0 @@
#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
-805
View File
@@ -1,805 +0,0 @@
#ifndef _KEYS_DEBUG_H_
#define _KEYS_DEBUG_H_
static const unsigned char system_fixed_aesKey[16] = //system_fixed_aesKey
{
0x52, 0x7C, 0xE6, 0x30, 0xA9, 0xCA, 0x30, 0x5F,
0x36, 0x96, 0xF3, 0xCD, 0xE9, 0x54, 0x19, 0x4B
};
static const unsigned char ctr_aes_common_key_dev0[16] = //ctr_aes_common_key_dev0
{
0x55, 0xA3, 0xF8, 0x72, 0xBD, 0xC8, 0x0C, 0x55,
0x5A, 0x65, 0x43, 0x81, 0x13, 0x9E, 0x15, 0x3B
};
static const unsigned char ctr_aes_common_key_dev1[16] = //ctr_aes_common_key_dev1
{
0x44, 0x34, 0xED, 0x14, 0x82, 0x0C, 0xA1, 0xEB,
0xAB, 0x82, 0xC1, 0x6E, 0x7B, 0xEF, 0x0C, 0x25
};
static const unsigned char common_dpki_aesKey[16] = //common_dpki_aesKey a.k.a. DSi DevCommonKey
{
0xA1, 0x60, 0x4A, 0x6A, 0x71, 0x23, 0xB5, 0x29,
0xAE, 0x8B, 0xEC, 0x32, 0xC8, 0x16, 0xFC, 0xAA
};
//ECC Keys
static const unsigned char xs_dpki_eccPubKey[60] = //xs_dpki_eccPubKey
{
0x01, 0xD5, 0xA2, 0x3C, 0xE8, 0xE9, 0xDF, 0x8C,
0x0A, 0xA5, 0xAA, 0xE1, 0x76, 0xE1, 0x24, 0x7C,
0x90, 0x97, 0xA6, 0xFE, 0x2A, 0xD3, 0x8C, 0xB4,
0xDE, 0x74, 0x32, 0xDE, 0x5B, 0x84, 0x01, 0xAC,
0xB2, 0x13, 0x71, 0x9D, 0x4B, 0x9C, 0xEB, 0xD4,
0x13, 0xC2, 0x27, 0x66, 0xC5, 0x5F, 0x83, 0x97,
0xC4, 0x83, 0xA3, 0x9E, 0x3B, 0xFC, 0xE8, 0xA9,
0xB5, 0x10, 0x3A, 0x7B
};
//RSA Keys
static const unsigned char dev_cert_root_rsa_pubk[0x200] =
{
0xD0, 0x1F, 0xE1, 0x00, 0xD4, 0x35, 0x56, 0xB2,
0x4B, 0x56, 0xDA, 0xE9, 0x71, 0xB5, 0xA5, 0xD3,
0x84, 0xB9, 0x30, 0x03, 0xBE, 0x1B, 0xBF, 0x28,
0xA2, 0x30, 0x5B, 0x06, 0x06, 0x45, 0x46, 0x7D,
0x5B, 0x02, 0x51, 0xD2, 0x56, 0x1A, 0x27, 0x4F,
0x9E, 0x9F, 0x9C, 0xEC, 0x64, 0x61, 0x50, 0xAB,
0x3D, 0x2A, 0xE3, 0x36, 0x68, 0x66, 0xAC, 0xA4,
0xBA, 0xE8, 0x1A, 0xE3, 0xD7, 0x9A, 0xA6, 0xB0,
0x4A, 0x8B, 0xCB, 0xA7, 0xE6, 0xFB, 0x64, 0x89,
0x45, 0xEB, 0xDF, 0xDB, 0x85, 0xBA, 0x09, 0x1F,
0xD7, 0xD1, 0x14, 0xB5, 0xA3, 0xA7, 0x80, 0xE3,
0xA2, 0x2E, 0x6E, 0xCD, 0x87, 0xB5, 0xA4, 0xC6,
0xF9, 0x10, 0xE4, 0x03, 0x22, 0x08, 0x81, 0x4B,
0x0C, 0xEE, 0xA1, 0xA1, 0x7D, 0xF7, 0x39, 0x69,
0x5F, 0x61, 0x7E, 0xF6, 0x35, 0x28, 0xDB, 0x94,
0x96, 0x37, 0xA0, 0x56, 0x03, 0x7F, 0x7B, 0x32,
0x41, 0x38, 0x95, 0xC0, 0xA8, 0xF1, 0x98, 0x2E,
0x15, 0x65, 0xE3, 0x8E, 0xED, 0xC2, 0x2E, 0x59,
0x0E, 0xE2, 0x67, 0x7B, 0x86, 0x09, 0xF4, 0x8C,
0x2E, 0x30, 0x3F, 0xBC, 0x40, 0x5C, 0xAC, 0x18,
0x04, 0x2F, 0x82, 0x20, 0x84, 0xE4, 0x93, 0x68,
0x03, 0xDA, 0x7F, 0x41, 0x34, 0x92, 0x48, 0x56,
0x2B, 0x8E, 0xE1, 0x2F, 0x78, 0xF8, 0x03, 0x24,
0x63, 0x30, 0xBC, 0x7B, 0xE7, 0xEE, 0x72, 0x4A,
0xF4, 0x58, 0xA4, 0x72, 0xE7, 0xAB, 0x46, 0xA1,
0xA7, 0xC1, 0x0C, 0x2F, 0x18, 0xFA, 0x07, 0xC3,
0xDD, 0xD8, 0x98, 0x06, 0xA1, 0x1C, 0x9C, 0xC1,
0x30, 0xB2, 0x47, 0xA3, 0x3C, 0x8D, 0x47, 0xDE,
0x67, 0xF2, 0x9E, 0x55, 0x77, 0xB1, 0x1C, 0x43,
0x49, 0x3D, 0x5B, 0xBA, 0x76, 0x34, 0xA7, 0xE4,
0xE7, 0x15, 0x31, 0xB7, 0xDF, 0x59, 0x81, 0xFE,
0x24, 0xA1, 0x14, 0x55, 0x4C, 0xBD, 0x8F, 0x00,
0x5C, 0xE1, 0xDB, 0x35, 0x08, 0x5C, 0xCF, 0xC7,
0x78, 0x06, 0xB6, 0xDE, 0x25, 0x40, 0x68, 0xA2,
0x6C, 0xB5, 0x49, 0x2D, 0x45, 0x80, 0x43, 0x8F,
0xE1, 0xE5, 0xA9, 0xED, 0x75, 0xC5, 0xED, 0x45,
0x1D, 0xCE, 0x78, 0x94, 0x39, 0xCC, 0xC3, 0xBA,
0x28, 0xA2, 0x31, 0x2A, 0x1B, 0x87, 0x19, 0xEF,
0x0F, 0x73, 0xB7, 0x13, 0x95, 0x0C, 0x02, 0x59,
0x1A, 0x74, 0x62, 0xA6, 0x07, 0xF3, 0x7C, 0x0A,
0xA7, 0xA1, 0x8F, 0xA9, 0x43, 0xA3, 0x6D, 0x75,
0x2A, 0x5F, 0x41, 0x92, 0xF0, 0x13, 0x61, 0x00,
0xAA, 0x9C, 0xB4, 0x1B, 0xBE, 0x14, 0xBE, 0xB1,
0xF9, 0xFC, 0x69, 0x2F, 0xDF, 0xA0, 0x94, 0x46,
0xDE, 0x5A, 0x9D, 0xDE, 0x2C, 0xA5, 0xF6, 0x8C,
0x1C, 0x0C, 0x21, 0x42, 0x92, 0x87, 0xCB, 0x2D,
0xAA, 0xA3, 0xD2, 0x63, 0x75, 0x2F, 0x73, 0xE0,
0x9F, 0xAF, 0x44, 0x79, 0xD2, 0x81, 0x74, 0x29,
0xF6, 0x98, 0x00, 0xAF, 0xDE, 0x6B, 0x59, 0x2D,
0xC1, 0x98, 0x82, 0xBD, 0xF5, 0x81, 0xCC, 0xAB,
0xF2, 0xCB, 0x91, 0x02, 0x9E, 0xF3, 0x5C, 0x4C,
0xFD, 0xBB, 0xFF, 0x49, 0xC1, 0xFA, 0x1B, 0x2F,
0xE3, 0x1D, 0xE7, 0xA5, 0x60, 0xEC, 0xB4, 0x7E,
0xBC, 0xFE, 0x32, 0x42, 0x5B, 0x95, 0x6F, 0x81,
0xB6, 0x99, 0x17, 0x48, 0x7E, 0x3B, 0x78, 0x91,
0x51, 0xDB, 0x2E, 0x78, 0xB1, 0xFD, 0x2E, 0xBE,
0x7E, 0x62, 0x6B, 0x3E, 0xA1, 0x65, 0xB4, 0xFB,
0x00, 0xCC, 0xB7, 0x51, 0xAF, 0x50, 0x73, 0x29,
0xC4, 0xA3, 0x93, 0x9E, 0xA6, 0xDD, 0x9C, 0x50,
0xA0, 0xE7, 0x38, 0x6B, 0x01, 0x45, 0x79, 0x6B,
0x41, 0xAF, 0x61, 0xF7, 0x85, 0x55, 0x94, 0x4F,
0x3B, 0xC2, 0x2D, 0xC3, 0xBD, 0x0D, 0x00, 0xF8,
0x79, 0x8A, 0x42, 0xB1, 0xAA, 0xA0, 0x83, 0x20,
0x65, 0x9A, 0xC7, 0x39, 0x5A, 0xB4, 0xF3, 0x29
};
static const unsigned char cpA_dpki_rsa_privExp[256] = //cpA_dpki_rsa_privExp
{
0x28, 0xCE, 0xDC, 0x39, 0x02, 0x7F, 0x3E, 0x8E,
0xAA, 0xB7, 0x59, 0x11, 0xE0, 0x68, 0xBF, 0x80,
0xA6, 0x44, 0x77, 0xDB, 0x1B, 0xA2, 0x50, 0xA3,
0x69, 0xE5, 0x96, 0xB2, 0xC4, 0xCA, 0x7A, 0x35,
0x0D, 0xFC, 0x4A, 0xB2, 0xFB, 0xC0, 0x18, 0xA5,
0x30, 0xB4, 0x9D, 0x10, 0x44, 0xD1, 0xAD, 0x33,
0xFD, 0x15, 0xA7, 0x8D, 0x0F, 0x17, 0xD5, 0xA4,
0xF5, 0x5E, 0x7F, 0x33, 0xF6, 0x80, 0x04, 0x27,
0x6A, 0xEA, 0x9C, 0xEE, 0x68, 0x04, 0x1A, 0xA5,
0xD4, 0x35, 0xA2, 0x25, 0xA2, 0x31, 0xD9, 0xF2,
0xF0, 0xAC, 0xDE, 0x69, 0xB6, 0x64, 0x56, 0x75,
0x2E, 0x9B, 0xEA, 0xDE, 0x2A, 0xBB, 0xD6, 0x00,
0xAA, 0xE6, 0x9B, 0xC2, 0xF6, 0x9F, 0x60, 0xCD,
0x0E, 0xFA, 0xB1, 0x14, 0x4A, 0x47, 0xD6, 0x63,
0x9A, 0xCD, 0x9C, 0x93, 0xB9, 0x09, 0x42, 0xDA,
0x8F, 0xFB, 0xE5, 0x7B, 0xF1, 0x4F, 0x96, 0x33,
0xF9, 0x45, 0x5B, 0xCC, 0x84, 0xAB, 0xC2, 0xD8,
0xC4, 0x0C, 0x85, 0xFA, 0x51, 0x28, 0xB9, 0x97,
0x95, 0x23, 0x8C, 0xB3, 0x1D, 0x4E, 0xB6, 0x1C,
0xCC, 0x60, 0x41, 0xFB, 0x26, 0xC7, 0xD6, 0xCB,
0x77, 0x18, 0xF7, 0xEA, 0xCD, 0x10, 0x3C, 0x5B,
0xA3, 0xC0, 0x77, 0x4C, 0x11, 0xF3, 0x74, 0x50,
0xEE, 0x23, 0x80, 0xC4, 0x5D, 0xDD, 0x57, 0xF5,
0x7D, 0x49, 0x57, 0x4A, 0xBA, 0x62, 0xBF, 0x06,
0xD9, 0xD1, 0x7F, 0x91, 0x10, 0x89, 0x6F, 0x49,
0x09, 0xD7, 0xE9, 0xAF, 0x4C, 0x9F, 0x67, 0x9D,
0x89, 0x82, 0xE4, 0xD5, 0xC1, 0x9A, 0xDC, 0x55,
0x79, 0xE7, 0xE9, 0x2D, 0x81, 0x42, 0x14, 0x55,
0x61, 0x47, 0x9B, 0xED, 0x76, 0x92, 0x1D, 0x2F,
0xB5, 0x7C, 0x28, 0x4B, 0xFF, 0x7B, 0xC2, 0x3B,
0x36, 0x73, 0x99, 0xA6, 0x21, 0x43, 0x0E, 0xA1,
0x1F, 0x82, 0xB8, 0x91, 0x71, 0x11, 0xB2, 0xC1
};
static const unsigned char cpA_dpki_rsa_pubMod[256] = //cpA_dpki_rsa_pubMod
{
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
};
static const unsigned char xs9_dpki_rsa_privExp[256] = //xs9_dpki_rsa_privExp
{
0x74, 0xCB, 0xCF, 0x1E, 0xD0, 0x2D, 0xD4, 0xF9,
0xE0, 0x05, 0xCE, 0x9C, 0x66, 0x3D, 0xE3, 0x62,
0x66, 0x62, 0x4E, 0xB5, 0x82, 0xE1, 0x24, 0x1B,
0x5F, 0x73, 0x2A, 0x7F, 0x1D, 0xB3, 0x6E, 0x50,
0x07, 0x83, 0xA0, 0xC0, 0xED, 0xCE, 0xB7, 0xF9,
0x3D, 0xAC, 0x61, 0xC5, 0x7B, 0x99, 0xA0, 0xBC,
0xCE, 0x42, 0x8F, 0xD3, 0xB0, 0xA5, 0xBF, 0x2A,
0x3D, 0x3E, 0x5E, 0xDC, 0x56, 0xC3, 0xA5, 0xDE,
0x35, 0xCD, 0x0A, 0x00, 0xF8, 0x17, 0x6B, 0x20,
0x79, 0xEF, 0xD8, 0x83, 0x23, 0xBF, 0x21, 0x28,
0xFF, 0x38, 0x7D, 0x80, 0x07, 0x15, 0x18, 0x6C,
0xB9, 0x20, 0xF8, 0x85, 0x77, 0xBC, 0xD9, 0x2A,
0x35, 0x1C, 0xFE, 0xE3, 0xF1, 0xE8, 0x98, 0x2E,
0xA0, 0x4A, 0x48, 0x77, 0x35, 0x03, 0xC9, 0x7A,
0xAC, 0xDA, 0xBE, 0x6D, 0x1D, 0xFB, 0xE4, 0xDE,
0xEC, 0x70, 0x65, 0xFA, 0x10, 0x65, 0xA4, 0xB8,
0x6A, 0xDF, 0x32, 0x6B, 0x8E, 0x28, 0x79, 0x25,
0x87, 0x72, 0xC0, 0x7C, 0x5B, 0x81, 0xBC, 0x81,
0x92, 0x44, 0x7D, 0xEA, 0x61, 0xBD, 0x3C, 0x48,
0xF3, 0x0E, 0x18, 0xDC, 0x8D, 0x89, 0xA0, 0x34,
0xC3, 0xAE, 0x9C, 0x57, 0x72, 0xA6, 0xD7, 0x7C,
0x79, 0xF7, 0xE9, 0x14, 0x6E, 0x15, 0xAC, 0x01,
0xFA, 0xFF, 0xC8, 0xA2, 0x2A, 0x3A, 0xAB, 0x24,
0x3C, 0x7E, 0x2E, 0xC5, 0xDA, 0x83, 0xD5, 0x9D,
0x24, 0x10, 0x83, 0x7A, 0xF4, 0xBB, 0xA3, 0x6F,
0x88, 0xCE, 0xEC, 0x24, 0x1B, 0xF4, 0x36, 0x2E,
0x96, 0xC9, 0x6D, 0x19, 0x02, 0xFE, 0xAA, 0x21,
0x3E, 0x95, 0xA7, 0xFE, 0x83, 0xC8, 0x99, 0x7F,
0xD1, 0xCB, 0x7C, 0x1F, 0x91, 0x30, 0xDB, 0xA4,
0xD3, 0xDD, 0xDA, 0x9B, 0x12, 0x4E, 0x24, 0xD1,
0xA5, 0x6F, 0x15, 0xFC, 0x2C, 0x72, 0x98, 0x2C,
0x89, 0xC5, 0x7D, 0x89, 0xDE, 0x2B, 0x4E, 0x01
};
static const unsigned char xs9_dpki_rsa_pubMod[256] = //xs9_dpki_rsa_pubMod
{
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
};
static const unsigned char DevNcsdCfa_privExp[256] = //DevNcsdCfa_privExp
{
0x32, 0x36, 0x43, 0xC2, 0xB3, 0x1A, 0x7E, 0x13,
0xAB, 0xA2, 0xB6, 0x8B, 0x4F, 0x05, 0xA7, 0xA6,
0xCD, 0xE7, 0xA6, 0x74, 0x47, 0x49, 0xE6, 0x51,
0xE4, 0x71, 0x74, 0x15, 0x76, 0x91, 0xF7, 0x92,
0xB1, 0x4E, 0xF6, 0x99, 0x73, 0x1E, 0xCF, 0xB5,
0x1D, 0x7C, 0xAF, 0xC5, 0xEA, 0x57, 0x01, 0xE5,
0x5C, 0x10, 0x47, 0xEA, 0x3A, 0x54, 0x86, 0x03,
0x2A, 0x76, 0x05, 0x72, 0x53, 0x16, 0xC2, 0xAE,
0x2D, 0xBE, 0x71, 0xF7, 0x17, 0x6B, 0x23, 0xDD,
0x2C, 0xB8, 0x8D, 0x13, 0x14, 0xE5, 0xDA, 0x3B,
0xC7, 0x33, 0x7A, 0xBA, 0xE5, 0x2A, 0x2B, 0x7D,
0x5A, 0x12, 0x27, 0x38, 0x56, 0xDF, 0xED, 0x70,
0x03, 0x0E, 0xED, 0x64, 0xC7, 0xF6, 0x54, 0xAC,
0xFE, 0x1D, 0x77, 0xA4, 0xE4, 0xBC, 0xEB, 0xB9,
0xA6, 0xC5, 0xFE, 0x3A, 0xAF, 0x58, 0x81, 0xE4,
0x3F, 0xA0, 0xE6, 0x93, 0x13, 0x2D, 0x98, 0x7D,
0xB3, 0xE2, 0xC9, 0xC8, 0xD6, 0x31, 0x91, 0x73,
0x9D, 0xCA, 0xC9, 0x44, 0xEF, 0xD0, 0x39, 0xBF,
0x38, 0xFD, 0x1C, 0x91, 0x72, 0x93, 0x40, 0xA9,
0x8A, 0x0D, 0x3E, 0x32, 0xC4, 0x59, 0x4B, 0x0C,
0xC7, 0xEA, 0x50, 0x41, 0x9F, 0xF5, 0xE2, 0xB7,
0x50, 0x7C, 0xE3, 0xC9, 0xEC, 0x46, 0x18, 0xAC,
0xB4, 0x91, 0x2A, 0x32, 0xE0, 0xD8, 0x10, 0x6F,
0xFC, 0x81, 0xB3, 0x95, 0xF3, 0xFC, 0x78, 0xC0,
0xEF, 0xE5, 0x7B, 0x8D, 0x14, 0xD4, 0x36, 0x26,
0x5F, 0xC6, 0x32, 0xC0, 0x19, 0x87, 0x5C, 0x77,
0x26, 0x37, 0xD8, 0xAE, 0x66, 0xD6, 0x0B, 0x28,
0x26, 0x43, 0x7C, 0x25, 0xDB, 0x6D, 0x5C, 0xE8,
0x94, 0x8F, 0xA9, 0x77, 0x07, 0xB2, 0xC0, 0x85,
0xCD, 0x41, 0xBA, 0x48, 0x88, 0x73, 0x34, 0xD5,
0x20, 0x8A, 0x0F, 0xE3, 0x9E, 0x99, 0xF0, 0xC8,
0xE8, 0xD9, 0x2C, 0x2A, 0x21, 0x69, 0xE4, 0xC1
};
static const unsigned char DevNcsdCfa_pubMod[256] = //DevNcsdCfa_pubMod
{
0xB9, 0x0C, 0xC4, 0xC6, 0x78, 0xF8, 0x6E, 0x30,
0x05, 0x28, 0xC1, 0xCB, 0xD2, 0xCF, 0xA7, 0x80,
0x5C, 0x57, 0x4D, 0x16, 0x9C, 0xAF, 0xA6, 0xCD,
0x01, 0xBB, 0x83, 0x33, 0xAD, 0x03, 0xBB, 0x06,
0x63, 0xD8, 0x17, 0xF5, 0xE3, 0xDF, 0xDA, 0x0D,
0x3B, 0x86, 0x0E, 0xA2, 0x80, 0x47, 0x94, 0x44,
0x6F, 0xD9, 0x97, 0x7E, 0x78, 0x6A, 0xC3, 0x93,
0x93, 0xEF, 0x02, 0xFC, 0x22, 0x9F, 0x80, 0x77,
0x8C, 0x70, 0x92, 0x1C, 0x43, 0xB1, 0x37, 0x4C,
0x76, 0xE0, 0x57, 0x3B, 0xAB, 0x89, 0xFF, 0xEF,
0xE5, 0xBB, 0x3E, 0xAB, 0x91, 0x39, 0xB8, 0xD9,
0x66, 0x0B, 0x64, 0x28, 0x91, 0x92, 0xE9, 0xD0,
0xB3, 0xDF, 0xD1, 0x4B, 0xC1, 0x73, 0xB5, 0x3F,
0x56, 0xA0, 0x40, 0x10, 0xFE, 0x15, 0x2B, 0x1F,
0xA2, 0x7A, 0xDE, 0x31, 0xB0, 0x26, 0x40, 0xC3,
0x57, 0xFD, 0x35, 0xCB, 0xF0, 0xFA, 0xFF, 0xFB,
0x6F, 0xDB, 0xCD, 0x34, 0x1D, 0x51, 0x2D, 0x2D,
0x81, 0x18, 0xFF, 0x0C, 0x08, 0x51, 0xD5, 0xB4,
0x4B, 0x56, 0x16, 0x02, 0x9F, 0x4E, 0x6A, 0xDF,
0x06, 0x6E, 0xCB, 0x72, 0x85, 0xE9, 0x2E, 0x43,
0xA2, 0x08, 0x78, 0x0C, 0x38, 0x9C, 0x19, 0xBD,
0x7B, 0x74, 0x74, 0x68, 0xC4, 0x2D, 0xC1, 0x35,
0x9E, 0x65, 0x3B, 0xD8, 0x99, 0x04, 0x1C, 0x8B,
0x93, 0x8E, 0x7E, 0x92, 0x7C, 0xBB, 0xDD, 0x60,
0xEC, 0xE7, 0xFE, 0x0E, 0x9D, 0x4F, 0x36, 0x46,
0xE6, 0xF1, 0x5C, 0x94, 0x70, 0xEE, 0x67, 0x5F,
0x36, 0x2B, 0x70, 0x44, 0x8D, 0xCA, 0x09, 0xB9,
0x58, 0x67, 0xD2, 0x9F, 0xAD, 0x1F, 0x13, 0x54,
0x74, 0xAD, 0xA6, 0x84, 0x44, 0x28, 0xF3, 0xDE,
0x7E, 0x4C, 0x20, 0x2B, 0xC5, 0xE9, 0x12, 0xE9,
0x5E, 0xFB, 0x8D, 0x77, 0xA9, 0xA4, 0xD2, 0x0D,
0x3C, 0x38, 0x24, 0xBE, 0xF5, 0x8A, 0xB5, 0xF5
};
static const unsigned char AccessDesc_privExp[256] = //AccessDesc_privExp
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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 AccessDesc_pubMod[256] = //AccessDesc_pubMod
{
0xF4, 0x3C, 0x45, 0x82, 0xFB, 0xF8, 0x90, 0x5D,
0x07, 0x02, 0x9F, 0x2A, 0x98, 0x8B, 0x63, 0xB7,
0xD3, 0x8F, 0x3C, 0xE2, 0xE0, 0xE0, 0x93, 0xBF,
0xDF, 0x32, 0x43, 0x4D, 0xBE, 0xF4, 0xD1, 0x7A,
0x3A, 0x4E, 0x54, 0x31, 0xD7, 0x73, 0xAE, 0x99,
0x4C, 0xC4, 0x1F, 0x3C, 0x3E, 0xF0, 0x57, 0x05,
0xA3, 0x8A, 0x45, 0x54, 0x60, 0xD8, 0x8F, 0xD9,
0x1D, 0x68, 0x0D, 0x0E, 0x2E, 0xEF, 0xC8, 0xE8,
0x3D, 0xC9, 0x19, 0xF3, 0x73, 0x1E, 0x2D, 0xDA,
0x77, 0x88, 0x3E, 0xCA, 0x5E, 0x25, 0x70, 0x4B,
0xF7, 0x70, 0x95, 0x83, 0x54, 0x24, 0xE0, 0xC3,
0x1A, 0x75, 0xDF, 0x61, 0x3D, 0xD1, 0x42, 0xEC,
0x35, 0x1B, 0x38, 0xD6, 0xC1, 0xF6, 0x7E, 0x18,
0x2A, 0x84, 0x85, 0xDD, 0x57, 0x74, 0x1F, 0x0A,
0x2E, 0xF6, 0xB2, 0x94, 0xA2, 0x3E, 0xE9, 0xA1,
0xD0, 0x09, 0xF7, 0x3A, 0x99, 0x80, 0x05, 0xAF,
0x57, 0x55, 0xEF, 0x52, 0xFA, 0x24, 0x3E, 0x7F,
0xD4, 0x7C, 0x41, 0x44, 0x7B, 0x06, 0x7F, 0xB9,
0x5B, 0x2E, 0x8E, 0x96, 0xAE, 0x46, 0x12, 0x4D,
0x64, 0x21, 0xE5, 0x0F, 0x85, 0xCC, 0xEB, 0x92,
0xE5, 0xF0, 0xF5, 0xA7, 0x42, 0x27, 0x3B, 0xEC,
0xF8, 0xE7, 0x81, 0x75, 0x6F, 0x63, 0x0A, 0x8B,
0x0D, 0x77, 0x38, 0x51, 0xE6, 0x66, 0x33, 0xBA,
0x79, 0xDC, 0x2F, 0x2C, 0x8F, 0xC3, 0x28, 0x06,
0xBB, 0x03, 0x9C, 0xDB, 0xD1, 0x64, 0x0A, 0x66,
0xF0, 0xF8, 0xC1, 0x2A, 0x49, 0x1D, 0x0C, 0x6E,
0x35, 0xBB, 0xEA, 0xB3, 0x5C, 0x0D, 0xE9, 0x95,
0x7C, 0x67, 0xBE, 0x65, 0x77, 0xEC, 0x07, 0xC0,
0x23, 0x05, 0x0A, 0x72, 0x48, 0x86, 0xE9, 0x9E,
0xFC, 0x25, 0x15, 0xE7, 0xC8, 0x21, 0x65, 0xE0,
0x1B, 0xD5, 0xD5, 0x0E, 0xD3, 0x11, 0x54, 0xBB,
0x29, 0x78, 0xBF, 0x2A, 0x3C, 0x3B, 0xB6, 0xB1
};
static const unsigned char CrrDevKey_privExp[256] = //CrrDevKey_privExp
{
0x8D, 0x27, 0x29, 0x6B, 0xC7, 0xA7, 0xED, 0xCD,
0x94, 0x2D, 0x36, 0x5E, 0x86, 0xA8, 0x26, 0xE7,
0x43, 0x9E, 0x64, 0xC8, 0xAA, 0x9A, 0x58, 0x21,
0x07, 0xF7, 0xB3, 0xFB, 0xCF, 0x8D, 0x3E, 0x53,
0xF0, 0x02, 0x25, 0x7B, 0x80, 0x18, 0x2E, 0x0D,
0x84, 0x7D, 0x6C, 0xE0, 0xDA, 0xC0, 0x17, 0xA6,
0xA5, 0x13, 0xE6, 0xFD, 0xBF, 0x98, 0xFC, 0x87,
0x9A, 0x9E, 0x0E, 0x13, 0x87, 0x66, 0x24, 0x8D,
0xA5, 0x6C, 0x58, 0x86, 0x10, 0x80, 0x90, 0x89,
0xEE, 0xFD, 0x40, 0x94, 0xCB, 0x1F, 0x26, 0xAB,
0xD1, 0xD3, 0xFF, 0xE9, 0x7B, 0x76, 0xDC, 0x65,
0xC0, 0x15, 0xD8, 0x9B, 0xF6, 0x29, 0xE1, 0x49,
0xE9, 0xDC, 0xBE, 0x24, 0x17, 0xFF, 0x09, 0x2C,
0xD6, 0xC4, 0x6D, 0x50, 0x33, 0xDC, 0xA0, 0x9D,
0x9D, 0xCC, 0xDD, 0x6E, 0x7B, 0xDF, 0x42, 0x22,
0x4D, 0x80, 0xC7, 0xEB, 0xCB, 0xB1, 0x60, 0x2F,
0x04, 0xEE, 0x04, 0x0E, 0x4C, 0x76, 0x49, 0x55,
0x92, 0xA5, 0xC1, 0x13, 0x60, 0x0A, 0x80, 0x15,
0x3D, 0x1C, 0xC6, 0x46, 0x57, 0x2E, 0x7C, 0xB0,
0x3D, 0x87, 0x06, 0x87, 0xFD, 0x31, 0xF8, 0xE7,
0x14, 0x97, 0x2A, 0x57, 0x40, 0xAC, 0x94, 0x61,
0xCD, 0xCF, 0xDE, 0x8C, 0x40, 0x46, 0x95, 0xA0,
0xD6, 0xF9, 0x2C, 0x08, 0x9B, 0x12, 0xBF, 0xF1,
0x88, 0x9C, 0x5D, 0x40, 0x32, 0x6D, 0x9D, 0x99,
0xA4, 0x80, 0xA6, 0xC2, 0x45, 0x5A, 0xD3, 0x22,
0xFE, 0xFA, 0x17, 0x54, 0x11, 0xEA, 0x41, 0xB4,
0xBD, 0x68, 0x1E, 0xDD, 0x3F, 0xE5, 0x92, 0xCB,
0x9E, 0xF8, 0xC0, 0x0A, 0x8B, 0xF5, 0x89, 0xA4,
0x03, 0x68, 0xF8, 0xF8, 0x99, 0x7C, 0xFE, 0xAD,
0x32, 0xDD, 0x5C, 0xB4, 0x06, 0x29, 0xDA, 0x96,
0x8B, 0xBA, 0xCB, 0x15, 0xDE, 0x38, 0x0D, 0xCA,
0xF7, 0x01, 0x65, 0xF6, 0x2D, 0x36, 0x6E, 0x71
};
static const unsigned char CrrDevKey_pubMod[256] = //CrrDevKey_pubMod
{
0xE2, 0xAD, 0xA6, 0xEA, 0xCA, 0xA3, 0xE8, 0xCC,
0xA9, 0x70, 0x1D, 0x2E, 0x23, 0x4B, 0xC6, 0x55,
0xCE, 0x13, 0xD9, 0xA7, 0x58, 0xB4, 0xC7, 0x73,
0x96, 0x1D, 0xE8, 0xC3, 0x09, 0x4D, 0x9B, 0xC3,
0xEB, 0x69, 0xA2, 0x37, 0x83, 0x5D, 0xD8, 0x37,
0x04, 0x72, 0x7A, 0x4F, 0xEA, 0x53, 0x98, 0x9D,
0x0E, 0x01, 0x34, 0x70, 0x9A, 0x82, 0x06, 0xE7,
0x6A, 0xC9, 0xF8, 0x0E, 0x49, 0x5A, 0xA4, 0xE7,
0x0E, 0xFA, 0xD4, 0xAB, 0x3B, 0xC5, 0xD7, 0xF1,
0xA4, 0xFC, 0x92, 0x7F, 0xD0, 0xF3, 0xCD, 0xD5,
0xB9, 0x2A, 0x1A, 0x41, 0x62, 0xB3, 0x7B, 0x3E,
0x1E, 0x35, 0x46, 0x41, 0x8E, 0xB2, 0x53, 0x1A,
0x60, 0xF8, 0xC2, 0xD1, 0x94, 0xB3, 0x9D, 0x76,
0x9F, 0x1D, 0x98, 0xAC, 0xF0, 0xCF, 0xE3, 0xA9,
0x05, 0x85, 0xF2, 0xBF, 0x55, 0x76, 0x1B, 0x89,
0x1C, 0xC3, 0x19, 0x2E, 0xEE, 0x94, 0xBE, 0x75,
0x0F, 0xA3, 0x76, 0x8B, 0x24, 0x24, 0x97, 0xFA,
0xC0, 0x53, 0x24, 0xF5, 0x85, 0x02, 0x19, 0x9D,
0xC5, 0x11, 0x2E, 0x6B, 0xA3, 0x26, 0xFE, 0xF7,
0x55, 0xD4, 0x23, 0x0A, 0x73, 0x3F, 0x37, 0x53,
0xEA, 0xC2, 0xB7, 0xC1, 0xC9, 0xD8, 0xF3, 0x2F,
0x78, 0x76, 0x4A, 0xA0, 0x69, 0x60, 0x91, 0xC2,
0x7D, 0x11, 0x74, 0xEF, 0x96, 0xD9, 0x74, 0x53,
0xB1, 0x1C, 0xB0, 0xC4, 0x32, 0x16, 0x82, 0x3B,
0xAF, 0x61, 0xB2, 0xDE, 0x38, 0x87, 0x3E, 0x37,
0x4B, 0xA3, 0x95, 0x88, 0x8E, 0xE0, 0x27, 0x9A,
0x1F, 0x7D, 0xB8, 0x23, 0xC3, 0x63, 0xE8, 0x68,
0x51, 0xD9, 0x8C, 0x4C, 0xC2, 0x59, 0x86, 0x49,
0xF7, 0x46, 0x9E, 0x3C, 0xD7, 0x9F, 0x89, 0x23,
0xB4, 0x73, 0x35, 0x2F, 0x18, 0x23, 0x76, 0xA3,
0x9F, 0x40, 0x0B, 0x76, 0x90, 0x85, 0xC8, 0x89,
0xDA, 0x65, 0xE7, 0x6E, 0xEF, 0x2E, 0xF5, 0x67
};
//Certificates
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
keys_retail.h
-553
View File
@@ -1,553 +0,0 @@
#ifndef _KEYS_RETAIL_H_
#define _KEYS_RETAIL_H_
#ifndef PUBLIC_BUILD
// AES KEYS
static const unsigned char common_key_prod_keyY0[16] =
{
0xD0, 0x7B, 0x33, 0x7F, 0x9C, 0xA4, 0x38, 0x59,
0x32, 0xA2, 0xE2, 0x57, 0x23, 0x23, 0x2E, 0xB9
};
static const unsigned char common_key_prod_keyY1[16] =
{
0x0C, 0x76, 0x72, 0x30, 0xF0, 0x99, 0x8F, 0x1C,
0x46, 0x82, 0x82, 0x02, 0xFA, 0xAC, 0xBE, 0x4C
};
static const unsigned char common_key_prod_keyY2[16] =
{
0xC4, 0x75, 0xCB, 0x3A, 0xB8, 0xC7, 0x88, 0xBB,
0x57, 0x5E, 0x12, 0xA1, 0x09, 0x07, 0xB8, 0xA4
};
static const unsigned char common_key_prod_keyY3[16] =
{
0xE4, 0x86, 0xEE, 0xE3, 0xD0, 0xC0, 0x9C, 0x90,
0x2F, 0x66, 0x86, 0xD4, 0xC0, 0x6F, 0x64, 0x9F
};
static const unsigned char common_key_prod_keyY4[16] =
{
0xED, 0x31, 0xBA, 0x9C, 0x04, 0xB0, 0x67, 0x50,
0x6C, 0x44, 0x97, 0xA3, 0x5B, 0x78, 0x04, 0xFC
};
static const unsigned char common_key_prod_keyY5[16] =
{
0x5E, 0x66, 0x99, 0x8A, 0xB4, 0xE8, 0x93, 0x16,
0x06, 0x85, 0x0F, 0xD7, 0xA1, 0x6D, 0xD7, 0x55
};
// RSA KEYS
static const unsigned char retail_cert_root_rsa_pubk[0x200] =
{
0xF8, 0x24, 0x6C, 0x58, 0xBA, 0xE7, 0x50, 0x03,
0x01, 0xFB, 0xB7, 0xC2, 0xEB, 0xE0, 0x01, 0x05,
0x71, 0xDA, 0x92, 0x23, 0x78, 0xF0, 0x51, 0x4E,
0xC0, 0x03, 0x1D, 0xD0, 0xD2, 0x1E, 0xD3, 0xD0,
0x7E, 0xFC, 0x85, 0x20, 0x69, 0xB5, 0xDE, 0x9B,
0xB9, 0x51, 0xA8, 0xBC, 0x90, 0xA2, 0x44, 0x92,
0x6D, 0x37, 0x92, 0x95, 0xAE, 0x94, 0x36, 0xAA,
0xA6, 0xA3, 0x02, 0x51, 0x0C, 0x7B, 0x1D, 0xED,
0xD5, 0xFB, 0x20, 0x86, 0x9D, 0x7F, 0x30, 0x16,
0xF6, 0xBE, 0x65, 0xD3, 0x83, 0xA1, 0x6D, 0xB3,
0x32, 0x1B, 0x95, 0x35, 0x18, 0x90, 0xB1, 0x70,
0x02, 0x93, 0x7E, 0xE1, 0x93, 0xF5, 0x7E, 0x99,
0xA2, 0x47, 0x4E, 0x9D, 0x38, 0x24, 0xC7, 0xAE,
0xE3, 0x85, 0x41, 0xF5, 0x67, 0xE7, 0x51, 0x8C,
0x7A, 0x0E, 0x38, 0xE7, 0xEB, 0xAF, 0x41, 0x19,
0x1B, 0xCF, 0xF1, 0x7B, 0x42, 0xA6, 0xB4, 0xED,
0xE6, 0xCE, 0x8D, 0xE7, 0x31, 0x8F, 0x7F, 0x52,
0x04, 0xB3, 0x99, 0x0E, 0x22, 0x67, 0x45, 0xAF,
0xD4, 0x85, 0xB2, 0x44, 0x93, 0x00, 0x8B, 0x08,
0xC7, 0xF6, 0xB7, 0xE5, 0x6B, 0x02, 0xB3, 0xE8,
0xFE, 0x0C, 0x9D, 0x85, 0x9C, 0xB8, 0xB6, 0x82,
0x23, 0xB8, 0xAB, 0x27, 0xEE, 0x5F, 0x65, 0x38,
0x07, 0x8B, 0x2D, 0xB9, 0x1E, 0x2A, 0x15, 0x3E,
0x85, 0x81, 0x80, 0x72, 0xA2, 0x3B, 0x6D, 0xD9,
0x32, 0x81, 0x05, 0x4F, 0x6F, 0xB0, 0xF6, 0xF5,
0xAD, 0x28, 0x3E, 0xCA, 0x0B, 0x7A, 0xF3, 0x54,
0x55, 0xE0, 0x3D, 0xA7, 0xB6, 0x83, 0x26, 0xF3,
0xEC, 0x83, 0x4A, 0xF3, 0x14, 0x04, 0x8A, 0xC6,
0xDF, 0x20, 0xD2, 0x85, 0x08, 0x67, 0x3C, 0xAB,
0x62, 0xA2, 0xC7, 0xBC, 0x13, 0x1A, 0x53, 0x3E,
0x0B, 0x66, 0x80, 0x6B, 0x1C, 0x30, 0x66, 0x4B,
0x37, 0x23, 0x31, 0xBD, 0xC4, 0xB0, 0xCA, 0xD8,
0xD1, 0x1E, 0xE7, 0xBB, 0xD9, 0x28, 0x55, 0x48,
0xAA, 0xEC, 0x1F, 0x66, 0xE8, 0x21, 0xB3, 0xC8,
0xA0, 0x47, 0x69, 0x00, 0xC5, 0xE6, 0x88, 0xE8,
0x0C, 0xCE, 0x3C, 0x61, 0xD6, 0x9C, 0xBB, 0xA1,
0x37, 0xC6, 0x60, 0x4F, 0x7A, 0x72, 0xDD, 0x8C,
0x7B, 0x3E, 0x3D, 0x51, 0x29, 0x0D, 0xAA, 0x6A,
0x59, 0x7B, 0x08, 0x1F, 0x9D, 0x36, 0x33, 0xA3,
0x46, 0x7A, 0x35, 0x61, 0x09, 0xAC, 0xA7, 0xDD,
0x7D, 0x2E, 0x2F, 0xB2, 0xC1, 0xAE, 0xB8, 0xE2,
0x0F, 0x48, 0x92, 0xD8, 0xB9, 0xF8, 0xB4, 0x6F,
0x4E, 0x3C, 0x11, 0xF4, 0xF4, 0x7D, 0x8B, 0x75,
0x7D, 0xFE, 0xFE, 0xA3, 0x89, 0x9C, 0x33, 0x59,
0x5C, 0x5E, 0xFD, 0xEB, 0xCB, 0xAB, 0xE8, 0x41,
0x3E, 0x3A, 0x9A, 0x80, 0x3C, 0x69, 0x35, 0x6E,
0xB2, 0xB2, 0xAD, 0x5C, 0xC4, 0xC8, 0x58, 0x45,
0x5E, 0xF5, 0xF7, 0xB3, 0x06, 0x44, 0xB4, 0x7C,
0x64, 0x06, 0x8C, 0xDF, 0x80, 0x9F, 0x76, 0x02,
0x5A, 0x2D, 0xB4, 0x46, 0xE0, 0x3D, 0x7C, 0xF6,
0x2F, 0x34, 0xE7, 0x02, 0x45, 0x7B, 0x02, 0xA4,
0xCF, 0x5D, 0x9D, 0xD5, 0x3C, 0xA5, 0x3A, 0x7C,
0xA6, 0x29, 0x78, 0x8C, 0x67, 0xCA, 0x08, 0xBF,
0xEC, 0xCA, 0x43, 0xA9, 0x57, 0xAD, 0x16, 0xC9,
0x4E, 0x1C, 0xD8, 0x75, 0xCA, 0x10, 0x7D, 0xCE,
0x7E, 0x01, 0x18, 0xF0, 0xDF, 0x6B, 0xFE, 0xE5,
0x1D, 0xDB, 0xD9, 0x91, 0xC2, 0x6E, 0x60, 0xCD,
0x48, 0x58, 0xAA, 0x59, 0x2C, 0x82, 0x00, 0x75,
0xF2, 0x9F, 0x52, 0x6C, 0x91, 0x7C, 0x6F, 0xE5,
0x40, 0x3E, 0xA7, 0xD4, 0xA5, 0x0C, 0xEC, 0x3B,
0x73, 0x84, 0xDE, 0x88, 0x6E, 0x82, 0xD2, 0xEB,
0x4D, 0x4E, 0x42, 0xB5, 0xF2, 0xB1, 0x49, 0xA8,
0x1E, 0xA7, 0xCE, 0x71, 0x44, 0xDC, 0x29, 0x94,
0xCF, 0xC4, 0x4E, 0x1F, 0x91, 0xCB, 0xD4, 0x95
};
static const unsigned char RetailAccessDesc_pubMod[0x100] =
{
0xB1, 0xE3, 0xE3, 0x5F, 0x01, 0x39, 0x80, 0xD1,
0x56, 0x78, 0x9D, 0xB7, 0x06, 0xF7, 0x1D, 0xBF,
0x3E, 0x22, 0x76, 0xED, 0xF9, 0x5D, 0xA2, 0x36,
0xB6, 0x30, 0x61, 0x05, 0x96, 0xD3, 0x00, 0xB9,
0xED, 0xF1, 0xD7, 0xE0, 0x1D, 0xA0, 0x4F, 0xB7,
0xCF, 0x5A, 0x19, 0x87, 0x75, 0x49, 0x88, 0x40,
0xED, 0xE3, 0x6F, 0x7C, 0x90, 0x4A, 0x64, 0x45,
0x98, 0xD7, 0x04, 0xB9, 0x5A, 0x6B, 0x45, 0xAA,
0x7E, 0x94, 0xC0, 0xB3, 0xB7, 0xDB, 0x7B, 0x66,
0x59, 0x20, 0xB7, 0x08, 0xE2, 0xF3, 0x83, 0xA3,
0x7F, 0xE3, 0x20, 0x21, 0xA0, 0xEB, 0xB7, 0x28,
0x0F, 0xF3, 0x2B, 0x15, 0xA4, 0xC9, 0xD0, 0xAB,
0x89, 0x39, 0x99, 0x7E, 0x76, 0x5F, 0x9E, 0x4D,
0x1E, 0x01, 0x22, 0x8D, 0x74, 0xA6, 0xEB, 0x9A,
0xA3, 0x9D, 0x45, 0xE5, 0x10, 0x61, 0x6E, 0x20,
0xFD, 0x23, 0x75, 0xC0, 0xC5, 0x05, 0x03, 0xC5,
0x4C, 0x02, 0x4F, 0x54, 0x4B, 0x57, 0x08, 0xB4,
0x46, 0xC3, 0x2C, 0xF1, 0xF9, 0x52, 0x6C, 0xCD,
0x14, 0x55, 0xA8, 0x55, 0x92, 0x6D, 0xE2, 0x4A,
0x41, 0x46, 0xEB, 0x08, 0xC5, 0xF3, 0xB4, 0x8D,
0x0D, 0x5E, 0x21, 0xEA, 0xAF, 0x4D, 0x27, 0x4D,
0xDE, 0x77, 0x93, 0x97, 0xE2, 0xC7, 0x6B, 0x66,
0x1F, 0xDB, 0x2D, 0x6E, 0xA9, 0x5F, 0x61, 0x14,
0x17, 0x7B, 0x2B, 0x66, 0x5A, 0xB5, 0x01, 0x89,
0xF2, 0x23, 0x75, 0x25, 0x25, 0x9C, 0x86, 0x9A,
0x89, 0xFF, 0x64, 0x1D, 0x5B, 0xCE, 0xD7, 0x7E,
0x3F, 0x2D, 0xA8, 0xDA, 0xB5, 0x5A, 0xC5, 0x5F,
0x59, 0x20, 0xB0, 0xED, 0x1C, 0x91, 0xFF, 0xA3,
0x27, 0xB8, 0x8E, 0xCF, 0x82, 0x15, 0xE5, 0x49,
0xEF, 0xE4, 0x58, 0xE1, 0x5F, 0x8F, 0x53, 0xB9,
0x33, 0x2A, 0x56, 0x24, 0xAA, 0xA1, 0xD3, 0x6E,
0x47, 0x1A, 0x63, 0x44, 0x19, 0xB3, 0x8E, 0xA5
};
static const unsigned char RetailNcsdCfa_pubMod[0x100] =
{
0xFB, 0xDE, 0xB8, 0x2B, 0x40, 0x93, 0x0F, 0xF6,
0xB1, 0x9A, 0x08, 0x06, 0x1B, 0x86, 0xFE, 0xD0,
0xDF, 0x10, 0x79, 0x17, 0x3D, 0x8C, 0xE2, 0x7A,
0xCE, 0x8F, 0x23, 0x45, 0xB9, 0x0A, 0x6D, 0xED,
0x30, 0x0E, 0xC1, 0xA8, 0x92, 0xC4, 0xBD, 0x1A,
0xCE, 0xA7, 0xAC, 0x77, 0xAA, 0x47, 0xE5, 0x20,
0x4A, 0x44, 0x91, 0xDF, 0x1C, 0xFE, 0x86, 0x28,
0x12, 0x2D, 0x66, 0xDF, 0xBE, 0xAD, 0x96, 0x61,
0xED, 0xF2, 0xF7, 0x41, 0x7B, 0x57, 0x88, 0x6B,
0x24, 0x1E, 0x7D, 0xEC, 0xBE, 0x98, 0x65, 0x65,
0x36, 0x65, 0x99, 0xA9, 0xFE, 0x24, 0x67, 0x85,
0x99, 0xEE, 0x2A, 0xAE, 0xEE, 0xB1, 0x81, 0x1A,
0x22, 0xE3, 0x6D, 0x75, 0x6E, 0x21, 0xBC, 0xEF,
0x11, 0x5C, 0x61, 0xAF, 0x0C, 0x30, 0x00, 0xB6,
0xA2, 0x23, 0xED, 0xFE, 0x70, 0x15, 0xDA, 0x52,
0xE1, 0xE6, 0x2D, 0xCE, 0x34, 0xE8, 0xAA, 0x4C,
0xF1, 0xD6, 0x67, 0x56, 0x57, 0xD3, 0xDB, 0xC0,
0x90, 0x49, 0x6F, 0x45, 0x73, 0x93, 0x4E, 0x30,
0x30, 0x70, 0xF5, 0xC9, 0x8F, 0x31, 0x25, 0xF2,
0xC2, 0xE7, 0x33, 0x7F, 0x4E, 0xB6, 0xF5, 0x2A,
0xDF, 0x20, 0x00, 0xE5, 0x79, 0xB2, 0xD0, 0xF9,
0x17, 0xF7, 0x7E, 0x16, 0x90, 0x40, 0x00, 0x57,
0x91, 0x44, 0x78, 0xEF, 0x1C, 0xE0, 0x85, 0x09,
0xDA, 0xF4, 0x14, 0x7E, 0x4B, 0xD7, 0x35, 0xD6,
0x87, 0x54, 0x8F, 0x2A, 0xB5, 0xA7, 0x6F, 0x50,
0xD0, 0xF7, 0xD1, 0xF1, 0x19, 0xC9, 0xAC, 0x22,
0x7E, 0x05, 0x11, 0xF5, 0xF2, 0x6D, 0xEE, 0x92,
0x27, 0x57, 0x5F, 0xE5, 0x15, 0x0D, 0x27, 0x68,
0xBF, 0x52, 0x65, 0x74, 0x73, 0xA6, 0x58, 0x6D,
0x79, 0x18, 0xAC, 0x31, 0xDD, 0xDD, 0x80, 0x8B,
0x75, 0x24, 0xE1, 0x17, 0xE1, 0x95, 0x25, 0x16,
0x29, 0xAB, 0x69, 0x69, 0xC8, 0x28, 0xEE, 0x5D
};
static const unsigned char retail_firm_pubk[0x100] =
{
0xDE, 0xCF, 0xB6, 0xFC, 0x3D, 0x33, 0xE9, 0x55,
0xFD, 0xAC, 0x90, 0xE8, 0x88, 0x17, 0xB0, 0x03,
0xA1, 0x6B, 0x9A, 0xAB, 0x72, 0x70, 0x79, 0x32,
0xA2, 0xA0, 0x8C, 0xBB, 0x33, 0x6F, 0xB0, 0x76,
0x96, 0x2E, 0xC4, 0xE9, 0x2E, 0xD8, 0x8F, 0x92,
0xC0, 0x2D, 0x4D, 0x41, 0x0F, 0xDE, 0x45, 0x1B,
0x25, 0x3C, 0xBE, 0x37, 0x6B, 0x45, 0x82, 0x21,
0xE6, 0x4D, 0xB1, 0x23, 0x81, 0x82, 0xB6, 0x81,
0x62, 0xB7, 0x30, 0xF4, 0x60, 0x4B, 0xC7, 0xF7,
0xF0, 0x17, 0x0C, 0xB5, 0x75, 0x88, 0x77, 0x93,
0x52, 0x63, 0x70, 0xF0, 0x0B, 0xC6, 0x73, 0x43,
0x41, 0xEE, 0xE4, 0xF0, 0x71, 0xEC, 0xC8, 0xC1,
0x32, 0xC4, 0xDC, 0xA9, 0x99, 0x1D, 0x31, 0xB8,
0xA4, 0x7E, 0xDD, 0x19, 0x04, 0x0F, 0x02, 0xA8,
0x1A, 0xAF, 0xB3, 0x48, 0x9A, 0x29, 0x29, 0x5E,
0x49, 0x84, 0xE0, 0x94, 0x11, 0xD1, 0x7E, 0xAB,
0xB2, 0xC0, 0x44, 0x7E, 0xA1, 0x1B, 0x5E, 0x9D,
0x0D, 0x1A, 0xF9, 0x02, 0x9A, 0x2E, 0x53, 0x03,
0x2D, 0x48, 0x96, 0x7C, 0x2C, 0xA6, 0xD7, 0xAC,
0xF1, 0xED, 0x2B, 0x18, 0xBB, 0x01, 0xCB, 0x13,
0xB9, 0xAC, 0xA6, 0xEE, 0x55, 0x00, 0x37, 0x7C,
0x69, 0x61, 0x62, 0x89, 0x01, 0x54, 0x77, 0x9F,
0x07, 0x5D, 0x26, 0x34, 0x3A, 0xA9, 0x49, 0xA5,
0xAF, 0xF2, 0x5E, 0x06, 0x51, 0xB7, 0x1C, 0xE0,
0xDE, 0xDA, 0x5C, 0x0B, 0x9F, 0x98, 0xC2, 0x15,
0xFD, 0xBA, 0xD8, 0xA9, 0x99, 0x00, 0xAB, 0xA4,
0x8E, 0x4A, 0x16, 0x9D, 0x66, 0x2A, 0xE8, 0x56,
0x64, 0xB2, 0xB6, 0xC0, 0x93, 0xAF, 0x4D, 0x38,
0xA0, 0x16, 0x5C, 0xE4, 0xBD, 0x62, 0xC2, 0x46,
0x6B, 0xC9, 0x5A, 0x59, 0x4A, 0x72, 0x58, 0xFD,
0xB2, 0xCC, 0x36, 0x87, 0x30, 0x85, 0xE8, 0xA1,
0x04, 0x5B, 0xE0, 0x17, 0x9B, 0xD0, 0xEC, 0x9B
};
#endif
//Certificates
static const unsigned char ca3_dpki_cert[0x400] =
{
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
};
#endif
keyset.c
-231
View File
@@ -1,231 +0,0 @@
#include "lib.h"
// KeyData
#include "keys_common.h"
#include "keys_retail.h"
#ifndef PUBLIC_BUILD
#include "keys_debug.h"
#endif
// Private Prototypes
int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource);
int SetUnFixedKey(keys_struct *keys, u8 *UnFixedKey);
void InitCommonKeySlots(keys_struct *keys);
int SetTIK_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetTMD_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetCFA_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetCCI_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetAccessDesc_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetCXI_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod);
int SetCaCert(keys_struct *keys, u8 *Cert);
int SetTikCert(keys_struct *keys, u8 *Cert);
int SetTmdCert(keys_struct *keys, u8 *Cert);
// Code
void InitKeys(keys_struct *keys)
{
memset(keys,0,sizeof(keys_struct));
InitCommonKeySlots(keys);
}
void SetKeys(keys_struct *keys)
{
if(keys->keyset == keyset_RETAIL){
/* AES Keys */
// CIA
//SetCommonKey(keys,(u8*)zeros_fixed_aesKey,1);
SetCurrentCommonKey(keys,1);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
/* RSA Keys */
keys->rsa.FalseSign = true;
// CIA
SetTIK_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)Dummy_rsa_privExp,(u8*)Dummy_rsa_pubMod);
/* Certs */
SetCaCert(keys,(u8*)ca3_dpki_cert);
SetTikCert(keys,(u8*)xsC_dpki_cert);
SetTmdCert(keys,(u8*)cpB_dpki_cert);
}
#ifndef PUBLIC_BUILD
else if(keys->keyset == keyset_DEBUG){
/* AES Keys */
// CIA
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev0,0);
SetCommonKey(keys,(u8*)ctr_aes_common_key_dev1,1);
SetCurrentCommonKey(keys,0);
// NCCH
keys->aes.NormalKey = (u8*)zeros_fixed_aesKey;
SetSystemFixedKey(keys,(u8*)system_fixed_aesKey);
/* RSA Keys */
// CIA
SetTIK_RsaKey(keys,(u8*)xs9_dpki_rsa_privExp,(u8*)xs9_dpki_rsa_pubMod);
SetTMD_RsaKey(keys,(u8*)cpA_dpki_rsa_privExp,(u8*)cpA_dpki_rsa_pubMod);
// CFA
SetCFA_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CCI
SetCCI_RsaKey(keys,(u8*)DevNcsdCfa_privExp,(u8*)DevNcsdCfa_pubMod);
// CXI
SetAccessDesc_RsaKey(keys,(u8*)AccessDesc_privExp,(u8*)AccessDesc_pubMod);
/* Certs */
SetCaCert(keys,(u8*)ca4_dpki_cert);
SetTikCert(keys,(u8*)xs9_dpki_cert);
SetTmdCert(keys,(u8*)cpA_dpki_cert);
}
#endif
// Checking if AccessDesc can be signed
u8 *tmp = malloc(0x100);
memset(tmp,0,0x100);
if(memcmp(tmp,keys->rsa.AccessDesc_Priv,0x100) == 0)
keys->rsa.RequiresPresignedDesc = true;
else
keys->rsa.RequiresPresignedDesc = false;
free(tmp);
return;
}
void FreeKeys(keys_struct *keys)
{
// AES
if(keys->aes.CommonKey){
for(int i = 0; i < 256; i++){
free(keys->aes.CommonKey[i]);
}
}
free(keys->aes.CommonKey);
free(keys->aes.SystemFixedKey);
free(keys->aes.UnFixedKey);
// RSA
free(keys->rsa.TIK_Priv);
free(keys->rsa.TIK_Pub);
free(keys->rsa.TMD_Priv);
free(keys->rsa.TMD_Pub);
free(keys->rsa.CFA_Priv);
free(keys->rsa.CFA_Pub);
free(keys->rsa.CCI_Priv);
free(keys->rsa.CCI_Pub);
free(keys->rsa.AccessDesc_Priv);
free(keys->rsa.AccessDesc_Pub);
// Certs
free(keys->certs.ca_cert);
free(keys->certs.tik_cert);
free(keys->certs.tmd_cert);
memset(keys,0,sizeof(keys_struct));
}
int SetRsaKeySet(u8 **PrivDest, u8 *PrivSource, u8 **PubDest, u8 *PubSource)
{
int result = 0;
if(PrivSource){
result = CopyData(PrivDest,PrivSource,0x100);
if(result) return result;
}
if(PubSource){
result = CopyData(PubDest,PubSource,0x100);
if(result) return result;
}
return 0;
}
int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index)
{
if(!keys) return -1;
return CopyData(&keys->aes.CommonKey[Index],CommonKey,16);
}
void InitCommonKeySlots(keys_struct *keys)
{
if(!keys->aes.CommonKey){
keys->aes.CommonKey = malloc(sizeof(u8*)*256);
memset(keys->aes.CommonKey,0,sizeof(u8*)*256);
}
}
int SetCurrentCommonKey(keys_struct *keys, u8 Index)
{
if(!keys) return -1;
keys->aes.CurrentCommonKey = Index;
return 0;
}
int SetSystemFixedKey(keys_struct *keys, u8 *SystemFixedKey)
{
if(!keys) return -1;
return CopyData(&keys->aes.SystemFixedKey,SystemFixedKey,16);
}
int SetUnFixedKey(keys_struct *keys, u8 *UnFixedKey)
{
if(!keys) return -1;
return CopyData(&keys->aes.UnFixedKey,UnFixedKey,16);
}
int SetTIK_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod)
{
if(!keys) return -1;
return SetRsaKeySet(&keys->rsa.TIK_Priv,PrivateExp,&keys->rsa.TIK_Pub,PublicMod);
}
int SetTMD_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod)
{
if(!keys) return -1;
return SetRsaKeySet(&keys->rsa.TMD_Priv,PrivateExp,&keys->rsa.TMD_Pub,PublicMod);
}
int SetCFA_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod)
{
if(!keys) return -1;
return SetRsaKeySet(&keys->rsa.CFA_Priv,PrivateExp,&keys->rsa.CFA_Pub,PublicMod);
}
int SetCCI_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod)
{
if(!keys) return -1;
return SetRsaKeySet(&keys->rsa.CCI_Priv,PrivateExp,&keys->rsa.CCI_Pub,PublicMod);
}
int SetAccessDesc_RsaKey(keys_struct *keys, u8 *PrivateExp, u8 *PublicMod)
{
if(!keys) return -1;
return SetRsaKeySet(&keys->rsa.AccessDesc_Priv,PrivateExp,&keys->rsa.AccessDesc_Pub,PublicMod);
}
int SetCaCert(keys_struct *keys, u8 *Cert)
{
if(!keys) return -1;
return CopyData(&keys->certs.ca_cert,Cert,0x400);
}
int SetTikCert(keys_struct *keys, u8 *Cert)
{
if(!keys) return -1;
return CopyData(&keys->certs.tik_cert,Cert,0x300);
}
int SetTmdCert(keys_struct *keys, u8 *Cert)
{
if(!keys) return -1;
return CopyData(&keys->certs.tmd_cert,Cert,0x400);
}
keyset.h
-83
View File
@@ -1,83 +0,0 @@
#ifndef _KEYSET_H_
#define _KEYSET_H_
typedef enum
{
keyset_DEBUG,
keyset_RETAIL,
} keysets;
typedef enum
{
not_preset,
app,
dlp,
demo,
} fixed_accessdesc_type;
// Structs
typedef struct
{
keysets keyset;
struct
{
fixed_accessdesc_type PresetType;
u32 TargetFirmware;
} AccessDescSign;
struct
{
// CIA
u8 **CommonKey;
u8 CurrentCommonKey;
// NCCH Keys
u8 *NormalKey;
u8 *SystemFixedKey;
u8 *UnFixedKey;
} aes;
struct
{
bool FalseSign;
// CIA RSA
u8 *TMD_Priv;
u8 *TMD_Pub;
u8 *TIK_Priv;
u8 *TIK_Pub;
// CFA
u8 *CFA_Priv;
u8 *CFA_Pub;
// CCI
u8 *CCI_Priv;
u8 *CCI_Pub;
// CXI
bool RequiresPresignedDesc;
u8 *AccessDesc_Priv;
u8 *AccessDesc_Pub;
} rsa;
struct
{
// CIA
u8 *ca_cert;
u8 *tik_cert;
u8 *tmd_cert;
} certs;
} keys_struct;
#endif
// Public Prototypes
void InitKeys(keys_struct *keys);
void SetKeys(keys_struct *keys);
void FreeKeys(keys_struct *keys);
int SetCommonKey(keys_struct *keys, u8 *CommonKey, u8 Index);
int SetCurrentCommonKey(keys_struct *keys, u8 Index);
int SetSystemFixedKey(keys_struct *keys, u8 *SystemFixedKey);
lib.h
-35
View File
@@ -1,35 +0,0 @@
#define _LARGEFILE_SOURCE
#define _LARGEFILE64_SOURCE
#define _FILE_OFFSET_BITS 64
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>
#include <time.h>
#include <unistd.h>
#include <math.h>
#ifdef _WIN32
#include <io.h>
#include <direct.h>
#include <windows.h>
//#include <wchar.h>
#else
#include <sys/stat.h>
#include <sys/types.h>
#endif
#include "types.h"
#include "utils.h"
#include "crypto.h"
#include "keyset.h"
#include "usersettings.h"
#include "libyaml/yaml.h"
#include "yaml_ctr.h"
logo_data.h
-29
View File
File diff suppressed because one or more lines are too long
makerom.c
-126
View File
@@ -1,126 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "ncsd.h"
#include "cia.h"
int main(int argc, char *argv[])
{
// Setting up user settings
user_settings *usrset = malloc(sizeof(user_settings));
if(usrset == NULL) {fprintf(stderr,"[!] MEM ERROR\n"); return -1;}
init_UserSettings(usrset);
int result;
#ifdef DEBUG
printf("[DEBUG] Parseing Args\n");
#endif
// Parsing command args
result = ParseArgs(argc,argv,usrset);
if(result < 0) goto finish;
#ifdef DEBUG
printf("[DEBUG] Importing Yaml Settings\n");
#endif
// Import RSF Settings if present
result = GetYamlSettings(usrset);
if(result < 0) goto finish;
// Setup Content 0
if(!usrset->IsBuildingNCCH0){ // Import Content 0
if(usrset->Content0IsNcch){
#ifdef DEBUG
printf("[DEBUG] Import NCCH0\n");
#endif
FILE *ncch0 = fopen(usrset->ContentPath[0],"rb");
if(!ncch0) {fprintf(stderr,"[MAKEROM ERROR] Failed to open Content 0: %s\n",usrset->ContentPath[0]); goto finish;}
fclose(ncch0);
usrset->Content0.size = GetFileSize_u64(usrset->ContentPath[0]);
usrset->Content0.buffer = malloc(usrset->Content0.size);
ncch0 = fopen(usrset->ContentPath[0],"rb");
ReadFile_64(usrset->Content0.buffer, usrset->Content0.size,0,ncch0);
fclose(ncch0);
}
else if(usrset->Content0IsSrl){
#ifdef DEBUG
printf("[DEBUG] Import SRL\n");
#endif
FILE *srl = fopen(usrset->SrlPath,"rb");
if(!srl) {fprintf(stderr,"[MAKEROM ERROR] Failed to open SRL: %s\n",usrset->SrlPath); goto finish;}
fclose(srl);
u64 size = GetFileSize_u64(usrset->SrlPath);
usrset->Content0.size = align_value(size,0x10);
usrset->Content0.buffer = malloc(usrset->Content0.size);
srl = fopen(usrset->SrlPath,"rb");
ReadFile_64(usrset->Content0.buffer,size,0,srl);
fclose(srl);
}
else if(usrset->ConvertCci){
#ifdef DEBUG
printf("[DEBUG] Import CCI\n");
#endif
FILE *cci = fopen(usrset->CciPath,"rb");
if(!cci) {fprintf(stderr,"[MAKEROM ERROR] Failed to open CCI: %s\n",usrset->CciPath); goto finish;}
fclose(cci);
usrset->Content0.size = GetFileSize_u64(usrset->CciPath);
usrset->Content0.buffer = malloc(usrset->Content0.size);
cci = fopen(usrset->CciPath,"rb");
ReadFile_64(usrset->Content0.buffer, usrset->Content0.size,0,cci);
fclose(cci);
}
}
else{// Build Content 0
#ifdef DEBUG
printf("[DEBUG] Build NCCH0\n");
#endif
result = build_NCCH(usrset);
if(result < 0) {
//fprintf(stderr,"[ERROR] %s generation failed\n",usrset->build_ncch_type == CXI? "CXI" : "CFA");
fprintf(stderr,"[RESULT] Failed to build outfile\n");
goto finish;
}
}
// Make CCI
if(usrset->out_format == CCI){
#ifdef DEBUG
printf("[DEBUG] Building CCI\n");
#endif
result = build_CCI(usrset);
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CCI\n"); goto finish; }
}
// Make CIA
else if(usrset->out_format == CIA){
#ifdef DEBUG
printf("[DEBUG] Building CIA\n");
#endif
result = build_CIA(usrset);
if(result < 0) { fprintf(stderr,"[RESULT] Failed to build CIA\n"); goto finish; }
}
// No Container Raw CXI/CFA
else if(usrset->out_format == CXI || usrset->out_format == CFA){
#ifdef DEBUG
printf("[DEBUG] Outputting NCCH, because No Container\n");
#endif
FILE *ncch_out = fopen(usrset->outfile,"wb");
if(!ncch_out) {
fprintf(stderr,"[ERROR] Failed to create '%s'\n",usrset->outfile);
fprintf(stderr,"[RESULT] Failed to build '%s'\n",usrset->out_format == CXI? "CXI" : "CFA");
result = FAILED_TO_CREATE_OUTFILE;
goto finish;
}
WriteBuffer(usrset->Content0.buffer,usrset->Content0.size,0,ncch_out);
fclose(ncch_out);
}
finish:
#ifdef DEBUG
printf("[DEBUG] Free Context\n");
#endif
free_UserSettings(usrset);
#ifdef DEBUG
printf("[DEBUG] Finished returning (result=%d)\n",result);
#endif
return result;
}
makerom.exe
BIN
View File
Binary file not shown.
ncch.c
-1087
View File
File diff suppressed because it is too large Load Diff
ncch.h
-236
View File
@@ -1,236 +0,0 @@
#ifndef _NCCH_H_
#define _NCCH_H_
typedef enum
{
NCCH_MEMERROR = -1,
SAVE_DATA_TOO_LARGE = -2,
NCCH_SECTION_NOT_EXIST = -3,
UNABLE_TO_LOAD_NCCH_KEY = -4,
NCCH_EXPORT_BUFFER_TOO_SMALL = -5,
NO_ROMFS_IN_CFA = -6,
NO_EXHEADER_IN_CXI = -7,
NO_EXEFS_IN_CXI = -8,
// SigCheck Errors
CXI_CORRUPT = -9,
ACCESSDESC_SIG_BAD = -10,
NCCH_HDR_SIG_BAD = -11,
// HashCheck Errors
ExHeader_Hashfail = -12,
Logo_Hashfail = -13,
ExeFs_Hashfail = -14,
RomFs_Hashfail = -15,
// Others
NCCH_BAD_YAML_SET = -16,
DATA_POS_DNE = -17,
} ncch_errors;
typedef enum
{
ncch_ExHeader = 1,
ncch_exefs,
ncch_romfs,
ncch_Logo,
ncch_PlainRegion,
} ncch_section;
typedef enum
{
NoKey,
KeyIsNormalFixed,
KeyIsSystemFixed,
KeyIsUnFixed,
KeyIsUnFixed2,
} ncch_key_type;
typedef enum
{
SecureCrypto2 = 3,
ContentPlatform = 4,
ContentType = 5,
ContentUnitSize = 6,
OtherFlag = 7
} ncch_flags;
typedef enum
{
FixedCryptoKey = 0x1,
NoMountRomFs = 0x2,
NoCrypto = 0x4,
} ncch_otherflag_bitmask;
typedef enum
{
RomFS = 0x1,
ExeFS = 0x2,
SystemUpdate = 0x4,
Manual = 0x8,
Child = (0x4|0x8),
Trial = 0x10
} ncch_content_bitmask;
typedef struct
{
u16 version;
u32 exheader_offset;
u32 exheader_size;
u64 logo_offset;
u64 logo_size;
u64 plain_region_offset;
u64 plain_region_size;
u64 exefs_offset;
u64 exefs_size;
u64 exefs_hash_src_size;
u64 romfs_offset;
u64 romfs_size;
u64 romfs_hash_src_size;
u8 titleID[8];
u8 programID[8];
}NCCH_STRUCT;
typedef struct
{
u8 magic[4];
u8 content_size[4];
u8 title_id[8];
u8 maker_code[2];
u8 version[2];
u8 reserved_0[4];
u8 program_id[8];
u8 reserved_1[0x10];
u8 logo_sha_256_hash[0x20];
u8 product_code[0x10];
u8 extended_header_sha_256_hash[0x20];
u8 extended_header_size[4];
u8 reserved_2[4];
u8 flags[8];
u8 plain_region_offset[4];
u8 plain_region_size[4];
u8 logo_region_offset[4];
u8 logo_region_size[4];
u8 exefs_offset[4];
u8 exefs_size[4];
u8 exefs_hash_size[4];
u8 reserved_4[4];
u8 romfs_offset[4];
u8 romfs_size[4];
u8 romfs_hash_size[4];
u8 reserved_5[4];
u8 exefs_sha_256_hash[0x20];
u8 romfs_sha_256_hash[0x20];
} NCCH_Header;
typedef struct
{
keys_struct *keys;
rsf_settings *yaml_set;
COMPONENT_STRUCT *out;
struct{
u8 *PubK;
u8 *PrivK;
} CxiRsaKey;
struct
{
u32 MediaSize;
bool IncludeExeFsLogo;
bool CompressCode;
bool UseOnSD;
bool Encrypt;
bool FreeProductCode;
bool IsCfa;
bool IsBuildingCodeSection;
bool UseRomFS;
} Options;
struct
{
FILE *elf;
u64 elf_size;
FILE *banner;
u64 banner_size;
FILE *icon;
u64 icon_size;
FILE *logo;
u64 logo_size;
FILE *code;
u64 code_size;
FILE *exheader;
u64 exheader_size;
FILE *romfs;
u64 romfs_size;
FILE *plainregion;
u64 plainregion_size;
} ComponentFilePtrs;
struct
{
COMPONENT_STRUCT Code;
COMPONENT_STRUCT Banner;
COMPONENT_STRUCT Icon;
} ExeFs_Sections;
struct
{
u32 TextAddress;
u32 TextSize;
u32 TextMaxPages;
u32 ROAddress;
u32 ROSize;
u32 ROMaxPages;
u32 DataAddress;
u32 DataSize;
u32 DataMaxPages;
u32 BSS_Size;
} CodeDetails;
struct
{
u64 TotalContentSize;
COMPONENT_STRUCT CommonHeader;
COMPONENT_STRUCT ExHeader;
u64 LogoOffset;
COMPONENT_STRUCT Logo;
u64 PlainRegionOffset;
COMPONENT_STRUCT PlainRegion;
u64 ExeFsOffset;
COMPONENT_STRUCT ExeFs;
u64 RomFsOffset;
COMPONENT_STRUCT RomFs;
} Sections;
} ncch_settings;
#endif
// NCCH Build Functions
int build_NCCH(user_settings *usrset);
// NCCH Read Functions
int VerifyNCCH(u8 *ncch, keys_struct *keys, bool SuppressOutput);
u8* RetargetNCCH(FILE *fp, u64 size, u8 *TitleId, u8 *ProgramId, keys_struct *keys);
NCCH_Header* GetNCCH_CommonHDR(void *out, FILE *fp, u8 *buf);
bool IsNCCH(FILE *fp, u8 *buf);
bool IsCfa(NCCH_Header* hdr);
u32 GetNCCH_MediaUnitSize(NCCH_Header* hdr);
u32 GetNCCH_MediaSize(NCCH_Header* hdr);
ncch_key_type GetNCCHKeyType(NCCH_Header* hdr);
int GetNCCHSection(u8 *dest, u64 dest_max_size, u64 src_pos, u8 *ncch, NCCH_STRUCT *ncch_ctx, keys_struct *keys, ncch_section section);
u8* GetNCCHKey(NCCH_Header* hdr, keys_struct *keys);
int GetCXIStruct(NCCH_STRUCT *ctx, NCCH_Header *header);
void ncch_get_counter(NCCH_STRUCT *ctx, u8 counter[16], u8 type);
void CryptNCCHSection(u8 *buffer, u64 size, u64 src_pos, NCCH_STRUCT *ctx, u8 key[16], u8 type);
ncsd.c
-564
View File
@@ -1,564 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "exheader.h"
#include "ncsd.h"
// Private Prototypes
/* RSA Crypto */
int SignCCI(u8 *Signature, u8 *NCSD_HDR);
int CheckCCISignature(u8 *Signature, u8 *NCSD_HDR);
/* cci_settings tools */
void init_CCISettings(cci_settings *set);
int get_CCISettings(cci_settings *cciset, user_settings *usrset);
void free_CCISettings(cci_settings *set);
/* CCI Data Gen/Write */
int BuildNCSDHeader(cci_settings *cciset, user_settings *usrset);
int BuildCardInfoHeader(cci_settings *cciset, user_settings *usrset);
int WriteCCI_HDR_ToFile(cci_settings *cciset);
int WriteCCI_Content_ToFile(cci_settings *cciset,user_settings *usrset);
int WriteCCI_DummyBytes(cci_settings *cciset);
/* Get Data from Content Files */
int CheckContent0(cci_settings *cciset, user_settings *usrset);
int GetDataFromContent0(cci_settings *cciset, user_settings *usrset);
int GetContentFP(cci_settings *cciset, user_settings *usrset);
/* Get Data from YAML Settings */
int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml);
int GetMediaSize(cci_settings *cciset, user_settings *usrset);
u64 GetUnusedSize(u64 MediaSize, u8 CardType);
int GetWriteableAddress(cci_settings *cciset, user_settings *usrset);
int GetCardInfoBitmask(cci_settings *cciset, user_settings *usrset);
int CheckMediaSize(cci_settings *cciset);
static InternalCCI_Context ctx;
// Code
int build_CCI(user_settings *usrset)
{
int result = 0;
// Init Settings
cci_settings *cciset = malloc(sizeof(cci_settings));
if(!cciset) {fprintf(stderr,"[CCI ERROR] MEM ERROR\n"); return MEM_ERROR;}
init_CCISettings(cciset);
// Get Settings
result = get_CCISettings(cciset,usrset);
if(result) goto finish;
// Create Output File
cciset->out = fopen(usrset->outfile,"wb");
if(!cciset->out){
fprintf(stderr,"[CCI ERROR] Failed to create '%s'\n",usrset->outfile);
result = FAILED_TO_CREATE_OUTFILE;
goto finish;
}
// Generate NCSD Header and Additional Header
result = BuildNCSDHeader(cciset,usrset);
if(result) goto finish;
BuildCardInfoHeader(cciset,usrset);
// Write to File
WriteCCI_HDR_ToFile(cciset);
result = WriteCCI_Content_ToFile(cciset,usrset);
if(result) goto finish;
// Fill out file if necessary
if(cciset->MediaFootPadding) WriteCCI_DummyBytes(cciset);
// Close output file
finish:
if(result != FAILED_TO_CREATE_OUTFILE && cciset->out) fclose(cciset->out);
free_CCISettings(cciset);
return result;
}
int SignCCI(u8 *Signature, u8 *NCSD_HDR)
{
return ctr_sig(NCSD_HDR,sizeof(NCSD_Header),Signature,ctx.keys->rsa.CCI_Pub,ctx.keys->rsa.CCI_Priv,RSA_2048_SHA256,CTR_RSA_SIGN);
}
int CheckCCISignature(u8 *Signature, u8 *NCSD_HDR)
{
return ctr_sig(NCSD_HDR,sizeof(NCSD_Header),Signature,ctx.keys->rsa.CCI_Pub,NULL,RSA_2048_SHA256,CTR_RSA_VERIFY);
}
void init_CCISettings(cci_settings *set)
{
memset(set,0,sizeof(cci_settings));
memset(&ctx,0,sizeof(InternalCCI_Context));
}
int get_CCISettings(cci_settings *cciset, user_settings *usrset)
{
ctx.keys = &usrset->keys;
int result = 0;
/* Importing Data from Content */
result = CheckContent0(cciset,usrset);
if(result) return result;
result = GetDataFromContent0(cciset,usrset);
if(result) return result;
result = GetContentFP(cciset,usrset);
if(result) return result;
/* Getting Data from YAML */
result = GetNCSDFlags(cciset,&usrset->yaml_set);
if(result) return result;
result = GetMediaSize(cciset,usrset);
if(result) return result;
result = CheckMediaSize(cciset);
if(result) return result;
/** Card Info Header Data **/
result = GetWriteableAddress(cciset,usrset);
if(result) return result;
result = GetCardInfoBitmask(cciset,usrset);
if(result) return result;
/* All Done */
return 0;
}
void free_CCISettings(cci_settings *set)
{
if(set->content){
for(int i = 1; i < 8; i++) {
if(set->content[i]) fclose(set->content[i]);
}
free(set->content);
}
free(set);
}
int BuildNCSDHeader(cci_settings *cciset, user_settings *usrset)
{
memcpy((u8*)ctx.commonHDR.magic,"NCSD",4);
u32_to_u8((u8*)ctx.commonHDR.media_size,(cciset->MediaSize/cciset->MediaUnitSize),LE);
memcpy((u8*)ctx.commonHDR.title_id,cciset->MediaID,8);
for(int i = 0; i < 8; i++){
u32_to_u8((u8*)ctx.commonHDR.offsetsize_table[i].offset,(cciset->ContentOffset[i]/cciset->MediaUnitSize),LE);
u32_to_u8((u8*)ctx.commonHDR.offsetsize_table[i].size,(cciset->ContentSize[i]/cciset->MediaUnitSize),LE);
memcpy((u8*)ctx.commonHDR.partition_id_table[i],cciset->ContentTitleID[i],8);
}
memcpy((u8*)ctx.commonHDR.partition_flags,cciset->NCSD_Flags,8);
if(SignCCI(ctx.Signature,(u8*)&ctx.commonHDR) != Good){
fprintf(stderr,"[CCI ERROR] Failed to sign CCI\n");
return CCI_SIG_FAIL;
}
return 0;
}
int BuildCardInfoHeader(cci_settings *cciset, user_settings *usrset)
{
u32_to_u8((u8*)ctx.CardInfoHDR.writable_address,(cciset->WritableAddress/cciset->MediaUnitSize),LE);
u32_to_u8((u8*)ctx.CardInfoHDR.card_info_bitmask,cciset->CardInfoBitmask,BE);
u32_to_u8((u8*)ctx.CardInfoHDR.media_size_used,cciset->TotalContentSize,LE);
memcpy((u8*)ctx.CardInfoHDR.ncch_0_title_id,cciset->ContentTitleID[0],8);
memcpy((u8*)ctx.CardInfoHDR.initial_data,cciset->InitialData,0x30);
if(!(usrset->OmitImportedNcchHdr && !usrset->IsBuildingNCCH0))
memcpy((u8*)ctx.CardInfoHDR.ncch_0_header,cciset->NCCH_HDR,0x100);
memcpy((u8*)ctx.DevCardInfoHDR.TitleKey,cciset->TitleKey,0x10);
return 0;
}
int WriteCCI_HDR_ToFile(cci_settings *cciset)
{
WriteBuffer(ctx.Signature,0x100,0,cciset->out);
WriteBuffer((u8*)&ctx.commonHDR,sizeof(NCSD_Header),0x100,cciset->out);
WriteBuffer((u8*)&ctx.CardInfoHDR,sizeof(CardInfo_Header),0x200,cciset->out);
WriteBuffer((u8*)&ctx.DevCardInfoHDR,sizeof(Dev_CardInfo_Header),0x1200,cciset->out);
return 0;
}
int WriteCCI_Content_ToFile(cci_settings *cciset,user_settings *usrset)
{
// Write Content 0
WriteBuffer(cciset->ncch0,cciset->ContentSize[0],cciset->ContentOffset[0],cciset->out);
free(usrset->Content0.buffer);
usrset->Content0.buffer = NULL;
usrset->Content0.size = 0;
// Add additional contents, recreating them with their new TitleID
for(int i = 1; i < 8; i++){
if(cciset->content[i]){
u8 *ContentBuff = RetargetNCCH(cciset->content[i],cciset->ContentSize[i],cciset->ContentTitleID[i],cciset->MediaID,ctx.keys);
if(!ContentBuff){
fprintf(stderr,"[CCI ERROR] Could not import content %d to CCI\n",i);
return FAILED_TO_IMPORT_FILE;
}
WriteBuffer(ContentBuff,cciset->ContentSize[i],cciset->ContentOffset[i],cciset->out);
free(ContentBuff);
}
}
return 0;
}
int WriteCCI_DummyBytes(cci_settings *cciset)
{
// Seeking end of CCI Data
fseek_64(cciset->out,cciset->TotalContentSize,SEEK_SET);
// Determining Size of Dummy Bytes
u64 len = cciset->MediaSize - cciset->TotalContentSize;
// Creating Buffer of Dummy Bytes
u8 dummy_bytes[cciset->MediaUnitSize];
memset(&dummy_bytes,0xff,cciset->MediaUnitSize);
// Writing Dummy Bytes to file
for(u64 i = 0; i < len; i += cciset->MediaUnitSize){
fwrite(&dummy_bytes,cciset->MediaUnitSize,1,cciset->out);
}
return 0;
}
int GetContentFP(cci_settings *cciset, user_settings *usrset)
{
cciset->content = malloc(sizeof(FILE*)*8);
if(!cciset->content){
fprintf(stderr,"[CCI ERROR] MEM ERROR\n");
return MEM_ERROR;
}
memset(cciset->content,0,sizeof(FILE*)*8);
for(int i = 1; i < 8; i++){
if(usrset->ContentPath[i]){
cciset->content[i] = fopen(usrset->ContentPath[i],"rb");
if(!cciset->content[i]){ // Checking if file could be opened
fprintf(stderr,"[CCI ERROR] Failed to create '%s'\n",usrset->outfile);
return FAILED_TO_OPEN_FILE;
}
if(!IsNCCH(cciset->content[i],NULL)){ // Checking if NCCH
fprintf(stderr,"[CCI ERROR] Content '%s' is invalid\n",usrset->ContentPath[i]);
return NCSD_INVALID_NCCH0;
}
// Getting NCCH Header
NCCH_Header *hdr = malloc(sizeof(NCCH_Header));;
GetNCCH_CommonHDR(hdr,cciset->content[i],NULL);
if(GetNCCH_MediaUnitSize(hdr) != cciset->MediaUnitSize){ // Checking if Media Unit Size matches CCI
fprintf(stderr,"[CCI ERROR] Content '%s' is invalid\n",usrset->ContentPath[i]);
return NCSD_INVALID_NCCH0;
}
memcpy(&cciset->ContentTitleID[i],cciset->MediaID,8); // Set TitleID
// Modify TitleID Accordingly
u16 tmp = u8_to_u16(&hdr->title_id[6],LE);
tmp |= (i+4);
u16_to_u8(&cciset->ContentTitleID[i][6],tmp,LE);
cciset->ContentSize[i] = GetNCCH_MediaSize(hdr)*cciset->MediaUnitSize;
cciset->ContentOffset[i] = cciset->TotalContentSize;
cciset->TotalContentSize += cciset->ContentSize[i];
free(hdr);
}
}
return 0;
}
int CheckContent0(cci_settings *cciset, user_settings *usrset)
{
if(!usrset->Content0.size)
return NCSD_NO_NCCH0;
cciset->ncch0 = usrset->Content0.buffer;
cciset->ncch0_FileLen = usrset->Content0.size;
if(!IsNCCH(NULL,cciset->ncch0))
return NCSD_INVALID_NCCH0;
return 0;
}
int GetDataFromContent0(cci_settings *cciset, user_settings *usrset)
{
cciset->TotalContentSize = 0x4000;
NCCH_Header *hdr;
hdr = GetNCCH_CommonHDR(NULL,NULL,cciset->ncch0);
cciset->NCCH_HDR = hdr;
u16 ncch_format_ver = u8_to_u16(hdr->version,LE);
if(ncch_format_ver != 0 && ncch_format_ver != 2){
fprintf(stderr,"[CCI ERROR] NCCH type %d Not Supported\n",ncch_format_ver);
return FAILED_TO_IMPORT_FILE;
}
//memdump(stdout,"ncch0 head: ",(cciset->ncch0+0x100),0x100);
//memdump(stdout,"ncch0 head: ",(u8*)(hdr),0x100);
memcpy(cciset->MediaID,hdr->title_id,8);
memcpy(&cciset->ContentTitleID[0],hdr->title_id,8);
if(usrset->GenSDKCardInfoHeader){
memcpy(cciset->InitialData,Stock_InitialData,0x30);
memcpy(cciset->TitleKey,Stock_TitleKey,0x10);
}
else{
u8 Hash[0x40];
ctr_sha(cciset->ncch0,0x80,Hash,CTR_SHA_256);
ctr_sha((cciset->ncch0+0x80),0x80,(Hash+0x20),CTR_SHA_256);
memcpy(cciset->InitialData,Hash,0x2C);
//memcpy(cciset->TitleKey,(Hash+0x30),0x10); // Might Remove
}
cciset->NCSD_Flags[MediaUnitSize] = hdr->flags[ContentUnitSize];
cciset->MediaUnitSize = GetNCCH_MediaUnitSize(hdr);
cciset->ContentSize[0] = (u64)(GetNCCH_MediaSize(hdr) * cciset->MediaUnitSize);
cciset->ContentOffset[0] = cciset->TotalContentSize;
cciset->TotalContentSize += cciset->ContentSize[0];
return 0;
}
int GetMediaSize(cci_settings *cciset, user_settings *usrset)
{
char *MediaSizeStr = usrset->yaml_set.BasicInfo.MediaSize;
if(!MediaSizeStr) cciset->MediaSize = (u64)GB*2;
else{
if(strcasecmp(MediaSizeStr,"128MB") == 0) cciset->MediaSize = (u64)MB*128;
else if(strcasecmp(MediaSizeStr,"256MB") == 0) cciset->MediaSize = (u64)MB*256;
else if(strcasecmp(MediaSizeStr,"512MB") == 0) cciset->MediaSize = (u64)MB*512;
else if(strcasecmp(MediaSizeStr,"1GB") == 0) cciset->MediaSize = (u64)GB*1;
else if(strcasecmp(MediaSizeStr,"2GB") == 0) cciset->MediaSize = (u64)GB*2;
else if(strcasecmp(MediaSizeStr,"4GB") == 0) cciset->MediaSize = (u64)GB*4;
else if(strcasecmp(MediaSizeStr,"8GB") == 0) cciset->MediaSize = (u64)GB*8;
else if(strcasecmp(MediaSizeStr,"16GB") == 0) cciset->MediaSize = (u64)GB*16;
else if(strcasecmp(MediaSizeStr,"32GB") == 0) cciset->MediaSize = (u64)GB*32;
else {
fprintf(stderr,"[CCI ERROR] Invalid MediaSize: %s\n",MediaSizeStr);
return INVALID_YAML_OPT;
}
}
if(usrset->yaml_set.BasicInfo.MediaFootPadding != -1) cciset->MediaFootPadding = usrset->yaml_set.BasicInfo.MediaFootPadding;
return 0;
}
u64 GetUnusedSize(u64 MediaSize, u8 CardType)
{
if(CardType == CARD1){
switch(MediaSize){
case (u64)MB*128: return (u64)2621440;
case (u64)MB*256: return (u64)5242880;
case (u64)MB*512: return (u64)10485760;
case (u64)GB*1: return (u64)73924608;
case (u64)GB*2: return (u64)147324928;
case (u64)GB*4: return (u64)294649856;
case (u64)GB*8: return (u64)587202560;
default: return (u64)((MediaSize/MB)*0x11800); // Aprox
}
}
else if(CardType == CARD2){
switch(MediaSize){
case (u64)MB*512: return (u64)37224448;
case (u64)GB*1: return (u64)73924608;
case (u64)GB*2: return (u64)147324928;
case (u64)GB*4: return (u64)294649856;
case (u64)GB*8: return (u64)587202560;
default: return (u64)((MediaSize/MB)*0x11800); // Aprox
}
}
return 0;
}
int GetNCSDFlags(cci_settings *cciset, rsf_settings *yaml)
{
/* BackupWriteWaitTime */
cciset->NCSD_Flags[FW6x_BackupWriteWaitTime] = 0;
if(yaml->CardInfo.BackupWriteWaitTime){
u32 WaitTime = strtoul(yaml->CardInfo.BackupWriteWaitTime,NULL,0);
if(WaitTime > 255){
fprintf(stderr,"[CCI ERROR] Invalid Card BackupWriteWaitTime (%d) : must 0-255\n",WaitTime);
return EXHDR_BAD_YAML_OPT;
}
cciset->NCSD_Flags[FW6x_BackupWriteWaitTime] = (u8)WaitTime;
}
/* FW6x SaveCrypto */
cciset->NCSD_Flags[FW6x_SaveCryptoFlag] = 1;
/* MediaType */
if(!yaml->CardInfo.MediaType) cciset->NCSD_Flags[MediaTypeIndex] = CARD1;
else{
if(strcasecmp(yaml->CardInfo.MediaType,"Card1") == 0) cciset->NCSD_Flags[MediaTypeIndex] = CARD1;
else if(strcasecmp(yaml->CardInfo.MediaType,"Card2") == 0) cciset->NCSD_Flags[MediaTypeIndex] = CARD2;
else {
fprintf(stderr,"[CCI ERROR] Invalid MediaType: %s\n",yaml->CardInfo.MediaType);
return INVALID_YAML_OPT;
}
}
/* Platform */
cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
/*
if(!yaml->TitleInfo.Platform) cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
else{
if(strcasecmp(yaml->TitleInfo.Platform,"ctr") == 0) cciset->NCSD_Flags[MediaPlatformIndex] = CTR;
else {
fprintf(stderr,"[CCI ERROR] Invalid Platform: %s\n",yaml->TitleInfo.Platform);
return INVALID_YAML_OPT;
}
}
*/
/* CardDevice */
if(!yaml->CardInfo.CardDevice) cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NONE;
else{
if(strcmp(yaml->CardInfo.CardDevice,"NorFlash") == 0) {
cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NOR_FLASH;
if(cciset->NCSD_Flags[MediaTypeIndex] == CARD2){
fprintf(stderr,"[CCI WARNING] 'CardDevice: NorFlash' is invalid on Card2\n");
cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NONE;
}
}
else if(strcmp(yaml->CardInfo.CardDevice,"None") == 0) cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_NONE;
else if(strcmp(yaml->CardInfo.CardDevice,"BT") == 0) cciset->NCSD_Flags[CardDeviceFlag] = CARD_DEVICE_BT;
else {
fprintf(stderr,"[CCI ERROR] Invalid CardDevice: %s\n",yaml->CardInfo.CardDevice);
return INVALID_YAML_OPT;
}
}
return 0;
}
int GetWriteableAddress(cci_settings *cciset, user_settings *usrset)
{
int result = GetSaveDataSize_yaml(&cciset->SaveDataSize,usrset);
if(result) return result;
char *WriteableAddressStr = usrset->yaml_set.CardInfo.WritableAddress;;
cciset->WritableAddress = -1;
if(cciset->NCSD_Flags[MediaTypeIndex] != CARD2) return 0; // Can only be set for Card2 Media
if(WriteableAddressStr){
if(strncmp(WriteableAddressStr,"0x",2) != 0){
fprintf(stderr,"[CCI ERROR] WritableAddress requires a Hexadecimal value\n");
return INVALID_YAML_OPT;
}
cciset->WritableAddress = strtoul((WriteableAddressStr+2),NULL,16);
}
if(cciset->WritableAddress == -1){ // If not set manually or is max size
if ((cciset->MediaSize / 2) < cciset->SaveDataSize){ // If SaveData size is greater than half the MediaSize
u64 saveDataSize = cciset->SaveDataSize / KB;
fprintf(stderr,"[CCI ERROR] Too large SaveDataSize %luK\n",saveDataSize);
return SAVE_DATA_TOO_LARGE;
}
if (cciset->SaveDataSize > (u64)(2047*MB)){ // Limit set by Nintendo
u64 saveDataSize = cciset->SaveDataSize / KB;
fprintf(stderr,"[CCI ERROR] Too large SaveDataSize %luK\n",saveDataSize);
return SAVE_DATA_TOO_LARGE;
}
u64 UnusedSize = GetUnusedSize(cciset->MediaSize,cciset->NCSD_Flags[MediaTypeIndex]); // Need to look into this
cciset->WritableAddress = cciset->MediaSize - UnusedSize - cciset->SaveDataSize;
}
return 0;
}
int GetCardInfoBitmask(cci_settings *cciset, user_settings *usrset)
{
char *str = usrset->yaml_set.CardInfo.CardType;
if(!str) cciset->CardInfoBitmask |= 0;
else{
if(strcasecmp(str,"s1") == 0) cciset->CardInfoBitmask |= 0;
else if(strcasecmp(str,"s2") == 0) cciset->CardInfoBitmask |= 0x20;
else {
fprintf(stderr,"[CCI ERROR] Invalid CardType: %s\n",str);
return INVALID_YAML_OPT;
}
}
str = usrset->yaml_set.CardInfo.CryptoType;
if(!str) cciset->CardInfoBitmask |= (3*0x40);
else{
int Value = strtol(str,NULL,10);
if(Value < 0 || Value > 3) {
fprintf(stderr,"[CCI ERROR] Invalid CryptoType: %s\n",str);
return INVALID_YAML_OPT;
}
if(Value != 3){
fprintf(stderr,"[CCI WARNING] Card crypto type = '%d'\n",Value);
}
cciset->CardInfoBitmask |= (Value*0x40);
}
return 0;
}
int CheckMediaSize(cci_settings *cciset)
{
if(cciset->TotalContentSize > cciset->MediaSize){
char *MediaSizeStr = NULL;
switch(cciset->MediaSize){
case (u64)128*MB: MediaSizeStr = " '128MB'"; break;
case (u64)256*MB: MediaSizeStr = " '256MB'"; break;
case (u64)512*MB: MediaSizeStr = " '512MB'"; break;
case (u64)1*GB: MediaSizeStr = " '1GB'"; break;
case (u64)2*GB: MediaSizeStr = " '2GB'"; break;
case (u64)4*GB: MediaSizeStr = " '4GB'"; break;
case (u64)8*GB: MediaSizeStr = " '8GB'"; break;
case (u64)16*GB: MediaSizeStr = " '16GB'"; break;
case (u64)32*GB: MediaSizeStr = " '32GB'"; break;
default: MediaSizeStr = ""; break;
}
fprintf(stderr,"[CCI ERROR] MediaSize%s is too Small\n",MediaSizeStr);
return INVALID_YAML_OPT;
}
return 0;
}
bool IsCci(u8 *ncsd)
{
NCSD_Header *hdr = (NCSD_Header*)(ncsd+0x100);
if(!hdr) return false;
if(memcmp(hdr->magic,"NCSD",4)!=0) return false;
if(hdr->partition_flags[MediaPlatformIndex] != CTR) return false;
if(hdr->partition_flags[MediaTypeIndex] != CARD1 && hdr->partition_flags[MediaTypeIndex] != CARD2) return false;
return true;
}
u8* GetPartition(u8 *ncsd, u8 index)
{
return (u8*)(ncsd+GetPartitionOffset(ncsd,index));
}
u64 GetPartitionOffset(u8 *ncsd, u8 index)
{
NCSD_Header *hdr = (NCSD_Header*)(ncsd+0x100);
u32 media_size = 0x200*pow(2,hdr->partition_flags[MediaUnitSize]);
u32 offset = u8_to_u64(hdr->offsetsize_table[index].offset,LE);
return offset*media_size;
}
u64 GetPartitionSize(u8 *ncsd, u8 index)
{
NCSD_Header *hdr = (NCSD_Header*)(ncsd+0x100);
u32 media_size = 0x200*pow(2,hdr->partition_flags[MediaUnitSize]);
u32 size = u8_to_u64(hdr->offsetsize_table[index].size,LE);
return size*media_size;
}
ncsd.h
-163
View File
@@ -1,163 +0,0 @@
#ifndef _NCSD_H_
#define _NCSD_H_
// Enums
typedef enum
{
NCSD_NO_NCCH0 = -1,
NCSD_INVALID_NCCH0 = -2,
INVALID_YAML_OPT = -3,
CCI_SIG_FAIL = -4,
} ncsd_errors;
typedef enum
{
FW6x_BackupWriteWaitTime = 0,
FW6x_SaveCryptoFlag = 1,
CardDeviceFlag = 3,
MediaPlatformIndex = 4,
MediaTypeIndex = 5,
MediaUnitSize = 6,
OldCardDeviceFlag = 7
} FlagIndex;
typedef enum
{
CARD_DEVICE_NOR_FLASH = 1,
CARD_DEVICE_NONE = 2,
CARD_DEVICE_BT = 3
} _CardDevice;
typedef enum
{
CTR = 1,
} _PlatformIndex;
typedef enum
{
INNER_DEVICE,
CARD1,
CARD2,
EXTENDED_DEVICE
} _TypeIndex;
// Structs
typedef struct
{
u8 offset[4];
u8 size[4];
} partition_offsetsize;
typedef struct
{
u8 magic[4];
u8 media_size[4];
u8 title_id[8];
u8 partitions_fs_type[8];
u8 partitions_crypto_type[8];
partition_offsetsize offsetsize_table[8];
u8 exheader_hash[0x20];
u8 additional_header_size[0x4];
u8 sector_zero_offset[0x4];
u8 partition_flags[8];
u8 partition_id_table[8][8];
u8 reserved[0x30];
} NCSD_Header;
typedef struct
{
u8 writable_address[4];
u8 card_info_bitmask[4];
// Notes
u8 reserved_0[0xf8];
u8 media_size_used[8];
u8 reserved_1[0x18];
u8 cver_title_id[8];
u8 cver_title_version[2];
u8 reserved_2[0xcd6];
//
u8 ncch_0_title_id[8];
u8 reserved_3[8];
u8 initial_data[0x30];
u8 reserved_4[0xc0];
u8 ncch_0_header[0x100];
} CardInfo_Header;
typedef struct
{
u8 CardDeviceReserved1[0x200];
u8 TitleKey[0x10];
u8 CardDeviceReserved2[0xf0];
} Dev_CardInfo_Header;
typedef struct
{
u8 Signature[0x100];
NCSD_Header commonHDR;
CardInfo_Header CardInfoHDR;
Dev_CardInfo_Header DevCardInfoHDR;
u8 *ContentImportBuffer;
keys_struct *keys;
} InternalCCI_Context;
typedef struct
{
u64 MediaSize;
u8 MediaID[8];
u8 NCSD_Flags[8];
u64 SaveDataSize;
u64 WritableAddress;
u32 CardInfoBitmask;
u8 InitialData[0x30];
NCCH_Header *NCCH_HDR;
u8 TitleKey[0x10];
u8 *ncch0;
u64 ncch0_FileLen;
FILE **content;
u64 ContentSize[CCI_MAX_CONTENT];
u64 ContentOffset[CCI_MAX_CONTENT];
u8 ContentTitleID[CCI_MAX_CONTENT][8];
u64 TotalContentSize;
bool MediaFootPadding;
u32 MediaUnitSize;
FILE *out;
} cci_settings;
static const u8 Stock_InitialData[0x30] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xAD, 0x88,
0xAC, 0x41, 0xA2, 0xB1, 0x5E, 0x8F,
0x66, 0x9C, 0x97, 0xE5, 0xE1, 0x5E,
0xA3, 0xEB, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const u8 Stock_TitleKey[0x10] =
{
0x6E, 0xC7, 0x5F, 0xB2, 0xE2, 0xB4,
0x87, 0x46, 0x1E, 0xDD, 0xCB, 0xB8,
0x97, 0x11, 0x92, 0xBA
};
#endif
// Public Prototypes
// Build Functions
int build_CCI(user_settings *usrset);
// Read Functions
bool IsCci(u8 *ncsd);
u8* GetPartition(u8 *ncsd, u8 index);
u64 GetPartitionOffset(u8 *ncsd, u8 index);
u64 GetPartitionSize(u8 *ncsd, u8 index);
romfs.c
-39
View File
@@ -1,39 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "romfs.h"
// RomFs Build Functions
int ImportRomFsBinaryFromFile(ncch_settings *ncchset);
int BuildRomFs(ncch_settings *ncchset)
{
int result = 0;
// If Not Using RomFS Return
if(!ncchset->Options.UseRomFS) return result;
if(ncchset->ComponentFilePtrs.romfs){ // The user has specified a pre-built RomFs Binary
result = ImportRomFsBinaryFromFile(ncchset);
return result;
}
// Need to implement RomFs generation
return result;
}
int ImportRomFsBinaryFromFile(ncch_settings *ncchset)
{
ncchset->Sections.RomFs.size = ncchset->ComponentFilePtrs.romfs_size;
ncchset->Sections.RomFs.buffer = malloc(ncchset->Sections.RomFs.size);
if(!ncchset->Sections.RomFs.buffer) {fprintf(stderr,"[ROMFS ERROR] MEM ERROR\n"); return MEM_ERROR;}
ReadFile_64(ncchset->Sections.RomFs.buffer,ncchset->Sections.RomFs.size,0,ncchset->ComponentFilePtrs.romfs);
if(memcmp(ncchset->Sections.RomFs.buffer,"IVFC",4) != 0){
fprintf(stderr,"[ROMFS ERROR] Invalid RomFS Binary.\n");
return INVALID_ROMFS_FILE;
}
return 0;
}
// RomFs Read Functions
romfs.h
-15
View File
@@ -1,15 +0,0 @@
#ifndef _ROMFS_H_
#define _ROMFS_H_
typedef enum
{
INVALID_ROMFS_FILE = -10,
} romfs_errors;
#endif
// RomFs Build Functions
int BuildRomFs(ncch_settings *ncchset);
// RomFs Read Functions
srl.h
-96
View File
@@ -1,96 +0,0 @@
#ifndef _SRL_H_
#define _SRL_H_
typedef struct
{
u8 game_title[0xC];
u8 game_code[4];
u8 maker_code[2];
u8 unit_code;
u8 encryption_seed_select;
u8 device_capacity;
u8 reserved_0[9];
u8 rom_version;
u8 internal_flag;
u8 arm9_rom_offset[4];
u8 arm9_entry_address[4];
u8 arm9_ram_address[4];
u8 arm9_size[4];
u8 arm7_rom_offset[4];
u8 arm7_entry_address[4];
u8 arm7_ram_address[4];
u8 arm7_size[4];
u8 fnt_offset[4];
u8 fnt_size[4];
u8 fat_offset[4];
u8 fat_size[4];
u8 arm9_overlay_offset[4];
u8 arm9_overlay_size[4];
u8 arm7_overlay_offset[4];
u8 arm7_overlay_size[4];
u8 normal_card_control_reg_settings[4];
u8 secure_card_control_reg_settings[4];
u8 icon_banner_offset[4];
u8 secure_area_crc[2];
u8 secure_transfer_timeout[2];
u8 arm9_autoload[4];
u8 arm7_autoload[4];
u8 secure_disable[8];
u8 ntr_rom_size[4];
u8 header_size[4];
u8 reserved_1[0x38];
u8 nintendo_logo[0x9C];
u8 nintendo_logo_crc[2];
u8 header_crc[2];
u8 debug_reserved[0x20];
//TWL Only Data
u8 config_settings[0x34];
u8 access_control[4];
u8 arm7_scfg_ext_mask[4];
u8 reserved_flags[4];
u8 arm9i_rom_offset[4];
u8 reserved_2[4];
u8 arm9i_load_address[4];
u8 arm9i_size[4];
u8 arm7i_rom_offset[4];
u8 struct_param_base_address[4];
u8 arm7i_load_address[4];
u8 arm7i_size[4];
u8 digest_ntr_region_offset[4];
u8 digest_ntr_region_size[4];
u8 digest_twl_region_offset[4];
u8 digest_twl_region_size[4];
u8 digest_sector_hashtable_offset[4];
u8 digest_sector_hashtable_size[4];
u8 digest_block_hashtable_offset[4];
u8 digest_block_hashtable_size[4];
u8 digest_sector_size[4];
u8 digest_block_sectorcount[4];
u8 reserved_3[8];
u8 twl_rom_size[8];
u8 unknown[8];
u8 modcrypt_area_1_offset[4];
u8 modcrypt_area_1_size[4];
u8 modcrypt_area_2_offset[4];
u8 modcrypt_area_2_size[4];
u8 title_id[8];
u8 pub_save_data_size[4];
u8 priv_save_data_size[4];
u8 reserved_4[0xC0];
// TWL and Signed NTR
u8 arm9_with_sec_area_sha1_hmac[0x14];
u8 arm7_sha1_hmac[0x14];
u8 digest_master_sha1_hmac[0x14];
u8 banner_sha1_hmac[0x14];
u8 arm9i_sha1_hmac[0x14];
u8 arm7i_sha1_hmac[0x14];
u8 reserved_5[0x28];
u8 arm9_sha1_hmac[0x14];
u8 reserved_6[0xA4C];
u8 reserved_7[0x180];
u8 signature[0x80];
} SRL_Header;
#endif
tik.c
-86
View File
@@ -1,86 +0,0 @@
#include "lib.h"
#include "cia.h"
#include "tik.h"
// Private Prototypes
int SetupTicketBuffer(COMPONENT_STRUCT *tik);
int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset);
int SignTicketHeader(TicketStruct *hdr, TicketSignatureStruct *sig, keys_struct *keys);
void SetContentIndexData(u8 *dest);
int BuildTicket(cia_settings *ciaset)
{
int result = 0;
result = SetupTicketBuffer(&ciaset->CIA_Sections.Ticket);
if(result) return result;
// Setting Ticket Struct Ptrs
TicketSignatureStruct *sig = (TicketSignatureStruct*)ciaset->CIA_Sections.Ticket.buffer;
TicketStruct *hdr = (TicketStruct*)(ciaset->CIA_Sections.Ticket.buffer+sizeof(TicketSignatureStruct));
result = SetupTicketHeader(hdr,ciaset);
if(result) return result;
result = SignTicketHeader(hdr,sig,ciaset->keys);
return 0;
}
int SetupTicketBuffer(COMPONENT_STRUCT *tik)
{
tik->size = sizeof(TicketSignatureStruct) + sizeof(TicketStruct);
tik->buffer = malloc(tik->size);
if(!tik->buffer) { fprintf(stderr,"[ERROR] MEM ERROR\n"); return MEM_ERROR; }
memset(tik->buffer,0,tik->size);
return 0;
}
int SetupTicketHeader(TicketStruct *hdr, cia_settings *ciaset)
{
memset(hdr,0,sizeof(TicketStruct));
memcpy(hdr->Issuer,ciaset->tik.TicketIssuer,0x40);
hdr->TicketFormatVersion = ciaset->tik.ticket_format_ver;
hdr->ca_crl_version = ciaset->cert.ca_crl_version;
hdr->signer_crl_version = ciaset->cert.signer_crl_version;
if(ciaset->content.EncryptContents)
CryptTitleKey(hdr->EncryptedTitleKey, ciaset->tik.TitleKey,ciaset->TitleID,ciaset->keys,ENC);
memcpy(hdr->TicketID,ciaset->tik.TicketID,8);
memcpy(hdr->DeviceID,ciaset->tik.DeviceID,8);
memcpy(hdr->TitleID,ciaset->TitleID,8);
memcpy(hdr->TicketVersion,ciaset->tik.TicketVersion,2);
hdr->CommonKeyID = ciaset->keys->aes.CurrentCommonKey;
SetContentIndexData(hdr->StaticData);
return 0;
}
int SignTicketHeader(TicketStruct *hdr, TicketSignatureStruct *sig, keys_struct *keys)
{
memset(sig,0,sizeof(TicketSignatureStruct));
u32_to_u8(sig->sig_type,RSA_2048_SHA256,BE);
return ctr_sig((u8*)hdr,sizeof(TicketStruct),sig->data,keys->rsa.TIK_Pub,keys->rsa.TIK_Priv,RSA_2048_SHA256,CTR_RSA_SIGN);
}
int CryptTitleKey(u8 *EncTitleKey, u8 *DecTitleKey, u8 *TitleID, keys_struct *keys, u8 mode)
{
//Generating IV
u8 iv[16];
memset(&iv,0x0,16);
memcpy(iv,TitleID,0x8);
//Setting up Aes Context
ctr_aes_context ctx;
memset(&ctx,0x0,sizeof(ctr_aes_context));
//Crypting TitleKey
ctr_init_aes_cbc(&ctx,keys->aes.CommonKey[keys->aes.CurrentCommonKey],iv,mode);
if(mode == ENC) ctr_aes_cbc(&ctx,DecTitleKey,EncTitleKey,0x10,ENC);
else ctr_aes_cbc(&ctx,EncTitleKey,DecTitleKey,0x10,DEC);
// Return
return 0;
}
void SetContentIndexData(u8 *dest)
{
memcpy(dest,normal_static_ticket_data,0x30);
}
tik.h
-80
View File
@@ -1,80 +0,0 @@
#ifndef _TIK_H_
#define _TIK_H_
static const unsigned char normal_static_ticket_data[0x30] =
{
0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAC,
0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x14,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x84,
0x00, 0x00, 0x00, 0x84, 0x00, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
};
/*
static const unsigned char system_static_ticket_data[0x30] =
{
0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAC,
0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x14,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x84,
0x00, 0x00, 0x00, 0x84, 0x00, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
};
*/
typedef enum
{
lic_Permanent = 0,
lic_Demo = 1,
lic_Trial = 2,
lic_Rental = 3,
lic_Subscription = 4,
lic_Service = 5,
lic_Mask = 15
} ticket_license_type;
typedef enum
{
right_Permanent = 1,
right_Subscription = 2,
right_Content = 3,
right_ContentConsumption = 4,
right_AccessTitle = 5
} ticket_item_rights;
typedef struct
{
u8 sig_type[4];
u8 data[0x100];
u8 padding[0x3C];
} TicketSignatureStruct;
typedef struct
{
u8 Issuer[0x40];
u8 ECDH[0x3c];
u8 TicketFormatVersion;
u8 ca_crl_version;
u8 signer_crl_version;
u8 EncryptedTitleKey[0x10];
u8 unknown_0;
u8 TicketID[8];
u8 DeviceID[4];
u8 TitleID[8];
u8 unknown_1[2];
u8 TicketVersion[2];
u8 unused_0[8];
u8 unused_1;
u8 CommonKeyID;
u8 unused_2[0x2F];
u8 unknown_2;
u8 unused_3[0x82];
u8 StaticData[0x30];
u8 unused_4[0x7C];
} TicketStruct;
#endif
// Prototypes
int BuildTicket(cia_settings *ciaset);
int CryptTitleKey(u8 *EncTitleKey, u8 *DecTitleKey, u8 *TitleID, keys_struct *keys, u8 mode);
titleid.c
-243
View File
@@ -1,243 +0,0 @@
#include "lib.h"
#include "ncch.h"
#include "titleid.h"
u32 SetPIDCategoryFromName(char *Category);
u32 SetPIDCategoryFromFlags(char **CategoryFlags, u32 FlagNum);
u32 SetPIDCategoryFromFlag(u32 Category, u32 Flag, char *FlagName);
u32 SetPIDUniqueId(char *UniqueIdStr);
u16 SetTitleVariation(u16 Category, rsf_settings *yaml_set);
u64 ConvertTwlIdToCtrId(u64 pgid)
{
return 0x0004800000000000 | (pgid & 0x00007FFFFFFFFFFF);
}
int GetProgramID(u64 *dest, rsf_settings *yaml, bool IsForExheader)
{
if(yaml->TitleInfo.Category && yaml->TitleInfo.CategoryFlags){
fprintf(stderr,"[ERROR] Can not set Cateory and CategoryFlags at the same time.\n");
return PID_BAD_YAML_SET;
}
u16 Type = 0x0004;
u32 m_Category = 0;
u32 UniqueId = 0;
u16 m_Variation = 0;
// Getting Category
if(yaml->TitleInfo.Category)
m_Category = SetPIDCategoryFromName(yaml->TitleInfo.Category);
else if(yaml->TitleInfo.CategoryFlags)
m_Category = SetPIDCategoryFromFlags(yaml->TitleInfo.CategoryFlags,yaml->TitleInfo.CategoryFlagsNum);
if(IsForExheader && yaml->TitleInfo.TargetCategory)
m_Category = SetPIDCategoryFromName(yaml->TitleInfo.TargetCategory);
if(m_Category == PID_INVALID_CATEGORY) // Error occured
return PID_BAD_YAML_SET;
// Getting UniqueId
if(yaml->TitleInfo.UniqueId) UniqueId = SetPIDUniqueId(yaml->TitleInfo.UniqueId);
else{
fprintf(stderr,"[ERROR] ParameterNotFound: TitleInfo/UniqueId\n");
return PID_BAD_YAML_SET;
}
m_Variation = SetTitleVariation(m_Category,yaml);
if(m_Variation == PID_INVALID_VARIATION) // Error occured
return PID_BAD_YAML_SET;
u16 Category = (u16)m_Category;
u8 Variation = (u8)m_Variation;
u64 ProgramID = 0;
ProgramID |= (u64)Variation<<0;
ProgramID |= (u64)UniqueId<<8;
ProgramID |= (u64)Category<<32;
ProgramID |= (u64)Type<<48;
*dest = ProgramID;
return 0;
}
int GetUniqueID(u32 *dest, rsf_settings *yaml)
{
if(yaml->TitleInfo.UniqueId) *dest = 0xffffff & SetPIDUniqueId(yaml->TitleInfo.UniqueId);
else{
fprintf(stderr,"[ERROR] ParameterNotFound: TitleInfo/UniqueId\n");
return PID_BAD_YAML_SET;
}
return 0;
}
u32 SetPIDCategoryFromName(char *Category)
{
if(strcmp(Category,"Application") == 0) return PROGRAM_ID_CATEGORY_APPLICATION;
else if(strcmp(Category,"SystemApplication") == 0) return PROGRAM_ID_CATEGORY_SYSTEM_APPLICATION;
else if(strcmp(Category,"Applet") == 0) return PROGRAM_ID_CATEGORY_APPLET;
else if(strcmp(Category,"Firmware") == 0) return PROGRAM_ID_CATEGORY_FIRMWARE;
else if(strcmp(Category,"Base") == 0) return PROGRAM_ID_CATEGORY_BASE;
else if(strcmp(Category,"DlpChild") == 0) return PROGRAM_ID_CATEGORY_DLP_CHILD;
else if(strcmp(Category,"Demo") == 0) return PROGRAM_ID_CATEGORY_DEMO;
else if(strcmp(Category,"Contents") == 0) return PROGRAM_ID_CATEGORY_CONTENTS;
else if(strcmp(Category,"SystemContents") == 0) return PROGRAM_ID_CATEGORY_SYSTEM_CONTENT;
else if(strcmp(Category,"SharedContents") == 0) return PROGRAM_ID_CATEGORY_SHARED_CONTENT;
else if(strcmp(Category,"AddOnContents") == 0) return PROGRAM_ID_CATEGORY_ADD_ON_CONTENTS;
else if(strcmp(Category,"Patch") == 0) return PROGRAM_ID_CATEGORY_PATCH;
else if(strcmp(Category,"AutoUpdateContents") == 0) return PROGRAM_ID_CATEGORY_AUTO_UPDATE_CONTENT;
else {
fprintf(stderr,"[ERROR] Invalid Category: %s\n",Category);
return PID_INVALID_CATEGORY;
}
}
u32 SetPIDCategoryFromFlags(char **CategoryFlags, u32 FlagNum)
{
u32 Category = 0;
for(u32 i = 0; i < FlagNum; i++){
if(strcmp(CategoryFlags[i],"Normal") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_NORMAL,"Normal");
else if(strcmp(CategoryFlags[i],"DlpChild") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_DLP_CHILD,"DlpChild");
else if(strcmp(CategoryFlags[i],"Demo") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_DEMO,"Demo");
else if(strcmp(CategoryFlags[i],"Contents") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_CONTENTS,"Contents");
else if(strcmp(CategoryFlags[i],"AddOnContents") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_ADD_ON_CONTENTS,"AddOnContents");
else if(strcmp(CategoryFlags[i],"Patch") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_PATCH,"Patch");
else if(strcmp(CategoryFlags[i],"CannotExecution") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION,"CannotExecution");
else if(strcmp(CategoryFlags[i],"System") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_SYSTEM,"System");
else if(strcmp(CategoryFlags[i],"RequireBatchUpdate") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_REQUIRE_BATCH_UPDATE,"RequireBatchUpdate");
else if(strcmp(CategoryFlags[i],"NotRequireUserApproval") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_USER_APPROVAL,"NotRequireUserApproval");
else if(strcmp(CategoryFlags[i],"NotRequireRightForMount") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_RIGHT_FOR_MOUNT,"NotRequireRightForMount");
else if(strcmp(CategoryFlags[i],"CanSkipConvertJumpId") == 0)
Category = SetPIDCategoryFromFlag(Category,PROGRAM_ID_CATEGORY_FLAG_CAN_SKIP_CONVERT_JUMP_ID,"CanSkipConvertJumpId");
else {
fprintf(stderr,"[ERROR] Invalid CategoryFlag: %s\n",CategoryFlags[i]);
return PID_INVALID_CATEGORY;
}
if(Category == PID_INVALID_CATEGORY) return PID_INVALID_CATEGORY;
}
return Category;
}
u32 SetPIDCategoryFromFlag(u32 Category, u32 Flag, char *FlagName)
{
if(!Flag) return Category;
if((Category & Flag) == Flag){
fprintf(stderr,"[ERROR] Failed to set '%s' for category. CategoryFlag was already set.\n",FlagName);
return PID_INVALID_CATEGORY;
}
return Category |= Flag;
}
u32 SetPIDUniqueId(char *UniqueIdStr)
{
return 0xffffff & strtoull(UniqueIdStr,NULL,0);
}
u16 SetTitleVariation(u16 Category, rsf_settings *yaml_set)
{
if(IsDemo(Category)){
if(yaml_set->TitleInfo.DemoIndex){
u16 DemoIndex = strtol(yaml_set->TitleInfo.DemoIndex,NULL,10);
if(DemoIndex > 255 || DemoIndex == 0){
fprintf(stderr,"[ERROR] Invalid demo index '%d'\n",DemoIndex);
return PID_INVALID_VARIATION;
}
return DemoIndex;
}
else{
fprintf(stderr,"[ERROR] ParameterNotFound: 'TitleInfo/DemoIndex'\n");
return PID_INVALID_VARIATION;
}
}
else if(IsDlpChild(Category)){
if(yaml_set->TitleInfo.ChildIndex){
u16 ChildIndex = strtol(yaml_set->TitleInfo.ChildIndex,NULL,10);
if(ChildIndex > 255){
fprintf(stderr,"[ERROR] Invalid child index '%d'\n",ChildIndex);
return PID_INVALID_VARIATION;
}
return ChildIndex;
}
else
return 0;
}
else if(IsAddOnContent(Category)){
if(yaml_set->TitleInfo.Variation){ // Might Rename to DataTitleIndex
u16 DataTitleIndex = strtol(yaml_set->TitleInfo.Variation,NULL,10);
if(DataTitleIndex > 255){
fprintf(stderr,"[ERROR] Invalid variation '%d'\n",DataTitleIndex);
return PID_INVALID_VARIATION;
}
return DataTitleIndex;
}
else
return 0;
}
else if(IsContents(Category)){
if(yaml_set->TitleInfo.ContentsIndex){
u16 ContentsIndex = strtol(yaml_set->TitleInfo.ContentsIndex,NULL,10);
if(ContentsIndex > 255){
fprintf(stderr,"[ERROR] Invalid content index '%d'\n",ContentsIndex);
return PID_INVALID_VARIATION;
}
return ContentsIndex;
}
else
return 0;
}
else{
if(yaml_set->TitleInfo.Version){
u16 Version = strtol(yaml_set->TitleInfo.Version,NULL,10);
if(Version > 255){
fprintf(stderr,"[ERROR] Invalid version '%d'\n",Version);
return PID_INVALID_VARIATION;
}
return Version;
}
else
return 0;
}
return PID_INVALID_VARIATION;
}
bool IsDemo(u16 Category)
{
return Category == PROGRAM_ID_CATEGORY_DEMO;
}
bool IsSystem(u16 Category)
{
return (Category & PROGRAM_ID_CATEGORY_FLAG_SYSTEM) == PROGRAM_ID_CATEGORY_FLAG_SYSTEM;
}
bool IsDlpChild(u16 Category)
{
return Category == PROGRAM_ID_CATEGORY_DLP_CHILD;
}
bool IsPatch(u16 Category)
{
return Category == PROGRAM_ID_CATEGORY_PATCH;
}
bool IsContents(u16 Category)
{
return (Category & PROGRAM_ID_CATEGORY_FLAG_CONTENTS) == PROGRAM_ID_CATEGORY_FLAG_CONTENTS;
}
bool IsAddOnContent(u16 Category)
{
return Category == PROGRAM_ID_CATEGORY_ADD_ON_CONTENTS;
}
titleid.h
-99
View File
@@ -1,99 +0,0 @@
#ifndef _TITLEID_H_
#define _TITLEID_H_
typedef enum
{
PID_BAD_YAML_SET = -1,
PID_INVALID_CATEGORY = 0x10000,
PID_INVALID_UNIQUE_ID = 0x1000000,
PID_INVALID_VARIATION = 0x100,
} Pid_Errors;
typedef enum
{
PROGRAM_ID_CATEGORY_FLAG_NORMAL = 0x0000,
PROGRAM_ID_CATEGORY_FLAG_DLP_CHILD = 0x0001,
PROGRAM_ID_CATEGORY_FLAG_DEMO = 0x0002,
PROGRAM_ID_CATEGORY_FLAG_CONTENTS = 0x0003,
PROGRAM_ID_CATEGORY_FLAG_ADD_ON_CONTENTS = 0x0004,
PROGRAM_ID_CATEGORY_FLAG_PATCH = 0x0006,
PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION = 0x0008,
PROGRAM_ID_CATEGORY_FLAG_SYSTEM = 0x0010,
PROGRAM_ID_CATEGORY_FLAG_REQUIRE_BATCH_UPDATE = 0x0020,
PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_USER_APPROVAL = 0x0040,
PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_RIGHT_FOR_MOUNT = 0x0080,
PROGRAM_ID_CATEGORY_FLAG_CAN_SKIP_CONVERT_JUMP_ID = 0x0100,
PROGRAM_ID_CATEGORY_FLAG_TWL = 0x8000,
} ProgramIdCategoryFlag;
typedef enum
{
PROGRAM_ID_CATEGORY_APPLICATION = ( PROGRAM_ID_CATEGORY_FLAG_NORMAL ),
PROGRAM_ID_CATEGORY_DLP_CHILD = ( PROGRAM_ID_CATEGORY_FLAG_DLP_CHILD ),
PROGRAM_ID_CATEGORY_DEMO = ( PROGRAM_ID_CATEGORY_FLAG_DEMO ),
PROGRAM_ID_CATEGORY_CONTENTS = ( PROGRAM_ID_CATEGORY_FLAG_CONTENTS ),
PROGRAM_ID_CATEGORY_PATCH = ( PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_PATCH),
PROGRAM_ID_CATEGORY_ADD_ON_CONTENTS = ( PROGRAM_ID_CATEGORY_FLAG_ADD_ON_CONTENTS
| PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_RIGHT_FOR_MOUNT ),
PROGRAM_ID_CATEGORY_FIRMWARE = ( PROGRAM_ID_CATEGORY_FLAG_NORMAL
| PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM
| PROGRAM_ID_CATEGORY_FLAG_REQUIRE_BATCH_UPDATE
| PROGRAM_ID_CATEGORY_FLAG_CAN_SKIP_CONVERT_JUMP_ID ),
PROGRAM_ID_CATEGORY_BASE = ( PROGRAM_ID_CATEGORY_FLAG_NORMAL
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM
| PROGRAM_ID_CATEGORY_FLAG_REQUIRE_BATCH_UPDATE
| PROGRAM_ID_CATEGORY_FLAG_CAN_SKIP_CONVERT_JUMP_ID ),
PROGRAM_ID_CATEGORY_APPLET = ( PROGRAM_ID_CATEGORY_FLAG_NORMAL
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM
| PROGRAM_ID_CATEGORY_FLAG_REQUIRE_BATCH_UPDATE ),
PROGRAM_ID_CATEGORY_SYSTEM_APPLICATION = ( PROGRAM_ID_CATEGORY_FLAG_NORMAL
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM ),
PROGRAM_ID_CATEGORY_SYSTEM_CONTENT = ( PROGRAM_ID_CATEGORY_FLAG_CONTENTS
| PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM ),
PROGRAM_ID_CATEGORY_SHARED_CONTENT = ( PROGRAM_ID_CATEGORY_FLAG_CONTENTS
| PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM
| PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_RIGHT_FOR_MOUNT ),
PROGRAM_ID_CATEGORY_AUTO_UPDATE_CONTENT = ( PROGRAM_ID_CATEGORY_FLAG_CONTENTS
| PROGRAM_ID_CATEGORY_FLAG_CANNOT_EXECUTION
| PROGRAM_ID_CATEGORY_FLAG_SYSTEM
| PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_USER_APPROVAL
| PROGRAM_ID_CATEGORY_FLAG_NOT_REQUIRE_RIGHT_FOR_MOUNT ),
} ProgramIdCategory;
#endif
u64 ConvertTwlIdToCtrId(u64 pgid);
int GetProgramID(u64 *dest, rsf_settings *yaml, bool IsForExheader);
int GetUniqueID(u32 *dest, rsf_settings *yaml);
bool IsDemo(u16 Category);
bool IsSystem(u16 Category);
bool IsDlpChild(u16 Category);
bool IsPatch(u16 Category);
bool IsContents(u16 Category);
bool IsAddOnContent(u16 Category);
tmd.c
-92
View File
@@ -1,92 +0,0 @@
#include "lib.h"
#include "cia.h"
#include "tmd.h"
// Private Prototypes
int SetupTMDBuffer(COMPONENT_STRUCT *tik);
int SetupTMDHeader(TMD_Struct *hdr, TMD_CONTENT_INFO_RECORD *info_record, cia_settings *ciaset);
int SignTMDHeader(TMD_Struct *hdr, TMD_SignatureStruct *sig, keys_struct *keys);
int SetupTMDInfoRecord(TMD_CONTENT_INFO_RECORD *info_record, u8 *content_record, u16 ContentCount);
int SetupTMDContentRecord(u8 *content_record, cia_settings *ciaset);
u32 PredictTMDSize(u16 ContentCount)
{
return sizeof(TMD_SignatureStruct) + sizeof(TMD_Struct) + sizeof(TMD_CONTENT_INFO_RECORD)*64 + sizeof(TMD_CONTENT_CHUNK_STRUCT)*ContentCount;
}
int BuildTMD(cia_settings *ciaset)
{
int result = 0;
result = SetupTMDBuffer(&ciaset->CIA_Sections.TitleMetaData);
if(result) return result;
// Setting TMD Struct Ptrs
TMD_SignatureStruct *sig = (TMD_SignatureStruct*)ciaset->CIA_Sections.TitleMetaData.buffer;
TMD_Struct *hdr = (TMD_Struct*)(ciaset->CIA_Sections.TitleMetaData.buffer+sizeof(TMD_SignatureStruct));
TMD_CONTENT_INFO_RECORD *info_record = (TMD_CONTENT_INFO_RECORD*)(ciaset->CIA_Sections.TitleMetaData.buffer+sizeof(TMD_SignatureStruct)+sizeof(TMD_Struct));
u8 *content_record = (u8*)(ciaset->CIA_Sections.TitleMetaData.buffer+sizeof(TMD_SignatureStruct)+sizeof(TMD_Struct)+sizeof(TMD_CONTENT_INFO_RECORD)*64);
SetupTMDContentRecord(content_record,ciaset);
SetupTMDInfoRecord(info_record,content_record,ciaset->content.ContentCount);
result = SetupTMDHeader(hdr,info_record,ciaset);
if(result) return result;
result = SignTMDHeader(hdr,sig,ciaset->keys);
return 0;
}
int SetupTMDBuffer(COMPONENT_STRUCT *tmd)
{
tmd->buffer = malloc(tmd->size); // already set before
if(!tmd->buffer) { fprintf(stderr,"[ERROR] MEM ERROR\n"); return MEM_ERROR; }
memset(tmd->buffer,0,tmd->size);
return 0;
}
int SetupTMDHeader(TMD_Struct *hdr, TMD_CONTENT_INFO_RECORD *info_record, cia_settings *ciaset)
{
memset(hdr,0,sizeof(TMD_Struct));
memcpy(hdr->Issuer,ciaset->tmd.TMDIssuer,0x40);
hdr->TMDFormatVersion = ciaset->tmd.tmd_format_ver;
hdr->ca_crl_version = ciaset->cert.ca_crl_version;
hdr->signer_crl_version = ciaset->cert.signer_crl_version;
memcpy(hdr->TitleID,ciaset->TitleID,8);
memcpy(hdr->TitleType,ciaset->Title_type,4);
memcpy(hdr->SaveDataSize,ciaset->tmd.SaveDataSize,4);
memcpy(hdr->PrivSaveDataSize,ciaset->tmd.PrivSaveDataSize,4);
hdr->TWL_Flag = ciaset->tmd.twl_flag;
memcpy(hdr->TitleVersion,ciaset->tmd.TitleVersion,2);
u16_to_u8(hdr->ContentCount,ciaset->content.ContentCount,BE);
ctr_sha(info_record,sizeof(TMD_CONTENT_INFO_RECORD)*64,hdr->sha_256_hash,CTR_SHA_256);
return 0;
}
int SignTMDHeader(TMD_Struct *hdr, TMD_SignatureStruct *sig, keys_struct *keys)
{
memset(sig,0,sizeof(TMD_SignatureStruct));
u32_to_u8(sig->sig_type,RSA_2048_SHA256,BE);
return ctr_sig((u8*)hdr,sizeof(TMD_Struct),sig->data,keys->rsa.TMD_Pub,keys->rsa.TMD_Priv,RSA_2048_SHA256,CTR_RSA_SIGN);
}
int SetupTMDInfoRecord(TMD_CONTENT_INFO_RECORD *info_record, u8 *content_record, u16 ContentCount)
{
memset(info_record,0x0,sizeof(TMD_CONTENT_INFO_RECORD)*0x40);
u16_to_u8(info_record->content_index_offset,0x0,BE);
u16_to_u8(info_record->content_command_count,ContentCount,BE);
ctr_sha(content_record,sizeof(TMD_CONTENT_CHUNK_STRUCT)*ContentCount,info_record->sha_256_hash,CTR_SHA_256);
return 0;
}
int SetupTMDContentRecord(u8 *content_record, cia_settings *ciaset)
{
for(int i = 0; i < ciaset->content.ContentCount; i++){
TMD_CONTENT_CHUNK_STRUCT *ptr = (TMD_CONTENT_CHUNK_STRUCT*)(content_record+sizeof(TMD_CONTENT_CHUNK_STRUCT)*i);
u32_to_u8(ptr->content_id,ciaset->content.ContentId[i],BE);
u16_to_u8(ptr->content_index,ciaset->content.ContentIndex[i],BE);
u16_to_u8(ptr->content_type,ciaset->content.ContentType[i],BE);
u64_to_u8(ptr->content_size,ciaset->content.ContentSize[i],BE);
memcpy(ptr->sha_256_hash,ciaset->content.ContentHash[i],0x20);
}
return 0;
}
tmd.h
-68
View File
@@ -1,68 +0,0 @@
#ifndef _TMD_H_
#define _TMD_H_
typedef enum
{
TYPE_CTR = 0x40,
TYPE_DATA = 0x8
} title_type;
typedef enum
{
Encrypted = 0x0001,
Optional = 0x4000,
Shared = 0x8000
} content_types;
typedef struct
{
u8 content_id[4];
u8 content_index[2];
u8 content_type[2];
u8 content_size[8];
u8 sha_256_hash[0x20];
} TMD_CONTENT_CHUNK_STRUCT;
typedef struct
{
u8 content_index_offset[2];
u8 content_command_count[2];
u8 sha_256_hash[0x20];
} TMD_CONTENT_INFO_RECORD;
typedef struct
{
u8 sig_type[4];
u8 data[0x100];
u8 padding[0x3C];
} TMD_SignatureStruct;
typedef struct
{
u8 Issuer[0x40];
u8 TMDFormatVersion;
u8 ca_crl_version;
u8 signer_crl_version;
u8 padding_1;
u8 SystemVersion[8];
u8 TitleID[8];
u8 TitleType[4];
u8 GroupID[2];
u8 SaveDataSize[4];
u8 PrivSaveDataSize[4]; // Zero for CXI Content0
u8 Reserved_0[4];
u8 TWL_Flag; // Zero for CXI Content0
u8 Reserved_1[0x31];
u8 AccessRights[4];
u8 TitleVersion[2];
u8 ContentCount[2];
u8 BootContent[2];
u8 Padding[2];
u8 sha_256_hash[0x20];
} TMD_Struct;
#endif
// Prototypes
u32 PredictTMDSize(u16 ContentCount);
int BuildTMD(cia_settings *ciaset);
types.h
-39
View File
@@ -1,39 +0,0 @@
#include <stdlib.h>
#include <stdint.h>
//Bools
typedef enum
{
Good,
Fail
} return_basic;
typedef enum
{
MEM_ERROR = -1,
FAILED_TO_OPEN_FILE = -2,
FAILED_TO_IMPORT_FILE = -3,
FAILED_TO_CREATE_OUTFILE = -4,
} global_errors;
typedef enum
{
BE = 0,
LE = 1
} endianness_flag;
typedef enum
{
KB = 1024,
MB = 1048576,
GB = 1073741824
} file_unit_size;
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned long long u64;
typedef signed char s8;
typedef signed short s16;
typedef signed int s32;
typedef signed long long s64;
usersettings.c
-847
View File
@@ -1,847 +0,0 @@
#include "lib.h"
// Private Prototypes
void DisplayHelp(char *app_name);
void SetDefaults(user_settings *set);
int SetArgument(int argc, int i, char *argv[], user_settings *set);
int CheckArgumentCombination(user_settings *set);
void PrintNeedsArgument(char *arg);
void PrintArgumentInvalid(char *arg);
void PrintNeedsParam(char *arg);
void PrintNoNeedParam(char *arg);
int ParseArgs(int argc, char *argv[], user_settings *usr_settings)
{
if(argv == NULL || usr_settings == NULL)
return USR_PTR_PASS_FAIL;
if(argc < 2){
DisplayHelp(argv[0]);
return USR_HELP;
}
// Detecting Help Requried
for(int i = 1; i < argc; i++){
if(strcmp(argv[i],"-help") == 0){
DisplayHelp(argv[0]);
return USR_HELP;
}
}
// Allocating Memory for Content Path Ptrs
usr_settings->ContentPath = malloc(CIA_MAX_CONTENT*sizeof(char*));
if(usr_settings->ContentPath == NULL){
fprintf(stderr,"[SETTING ERROR] MEM ERROR\n");
return USR_MEM_ERROR;
}
memset(usr_settings->ContentPath,0,CIA_MAX_CONTENT*sizeof(char*));
// Initialise Keys
InitKeys(&usr_settings->keys);
// Setting Defaults
SetDefaults(usr_settings);
// Parsing Arguments
int set_result;
int i = 1;
while(i < argc){
set_result = SetArgument(argc,i,argv,usr_settings);
if(set_result < 1){
fprintf(stderr,"[RESULT] Invalid arguments, see '%s -help'\n",argv[0]);
return set_result;
}
i += set_result;
}
// Checking arguments
set_result = CheckArgumentCombination(usr_settings);
if(set_result) return set_result;
// Setting Keys
SetKeys(&usr_settings->keys);
if(!usr_settings->outfile){
char *source_path = NULL;
if(usr_settings->IsBuildingNCCH0) source_path = usr_settings->rsf_path;
else if(usr_settings->ConvertCci) source_path = usr_settings->CciPath;
else if(usr_settings->Content0IsSrl) source_path = usr_settings->SrlPath;
else source_path = usr_settings->ContentPath[0];
u16 outfile_len = strlen(source_path) + 3;
usr_settings->outfile = malloc(outfile_len);
if(!usr_settings->outfile){
fprintf(stderr,"[SETTING ERROR] MEM ERROR\n");
return USR_MEM_ERROR;
}
usr_settings->outfile_mallocd = true;
append_filextention(usr_settings->outfile,outfile_len,source_path,(char*)&output_extention[usr_settings->out_format-1]);
}
return 0;
}
void SetDefaults(user_settings *set)
{
// Target Info
set->keys.keyset = keyset_RETAIL;
// Build NCCH Info
set->IsBuildingNCCH0 = true;
set->include_exefs_logo = false;
set->out_format = CXI;
set->build_ncch_type = format_not_set;
// Yaml Settings
set->yaml_set.Option.EnableCompress = true;
set->yaml_set.Option.EnableCrypt = true;
set->yaml_set.Option.UseOnSD = false;
set->yaml_set.Option.FreeProductCode = false;
// Content0 Info
set->Content0IsNcch = true;
set->ConvertCci = false;
set->Content0IsSrl = false;
set->Version[0] = 0xffff;
// CCI Info
set->GenSDKCardInfoHeader = false;
set->OmitImportedNcchHdr = false;
// CIA Info
set->EncryptContents = true;
set->RandomTitleKey = false;
for(int i = 0; i < CIA_MAX_CONTENT; i++){
set->ContentID[i] = 0x100000000;
}
}
int SetArgument(int argc, int i, char *argv[], user_settings *set)
{
bool IsLastArg = (i >= (argc -1));
bool HasParam = false;
if(!IsLastArg){
if(argv[i+1][0] != '-') HasParam = true;
}
if(strcmp(argv[i],"-elf") == 0){
if(!HasParam){
PrintNeedsParam("-elf");
return USR_ARG_REQ_PARAM;
}
set->elf_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-rsf") == 0){
if(!HasParam){
PrintNeedsParam("-rsf");
return USR_ARG_REQ_PARAM;
}
set->rsf_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-icon") == 0){
if(!HasParam){
PrintNeedsParam("-icon");
return USR_ARG_REQ_PARAM;
}
set->icon_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-banner") == 0){
if(!HasParam){
PrintNeedsParam("-banner");
return USR_ARG_REQ_PARAM;
}
set->banner_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-logo") == 0){
if(!HasParam){
PrintNeedsParam("-logo");
return USR_ARG_REQ_PARAM;
}
set->logo_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-o") == 0){
if(!HasParam){
PrintNeedsParam("-o");
return USR_ARG_REQ_PARAM;
}
set->outfile = argv[i+1];
set->outfile_mallocd = false;
return 2;
}
else if(strcmp(argv[i],"-exheader") == 0){
if(!HasParam){
PrintNeedsParam("-exheader");
return USR_ARG_REQ_PARAM;
}
set->exheader_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-code") == 0){
if(!HasParam){
PrintNeedsParam("-code");
return USR_ARG_REQ_PARAM;
}
set->exefs_code_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-romfs") == 0){
if(!HasParam){
PrintNeedsParam("-romfs");
return USR_ARG_REQ_PARAM;
}
set->romfs_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-plain-region") == 0){
if(!HasParam){
PrintNeedsParam("-plain-region");
return USR_ARG_REQ_PARAM;
}
set->plain_region_path = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-target") == 0){
if(!HasParam){
PrintNeedsParam("-target");
return USR_ARG_REQ_PARAM;
}
if(strcasecmp(argv[i+1],"debug") == 0 || strcasecmp(argv[i+1],"dev") == 0)
set->keys.keyset = keyset_DEBUG;
else if(strcasecmp(argv[i+1],"retail") == 0 || strcasecmp(argv[i+1],"prod") == 0)
set->keys.keyset = keyset_RETAIL;
else{
fprintf(stderr,"[SETTING ERROR] Unrecognised target '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
return 2;
}
else if(strcmp(argv[i],"-cci") == 0){
if(!HasParam){
PrintNeedsParam("-cci");
return USR_ARG_REQ_PARAM;
}
set->ConvertCci = true;
set->Content0IsSrl = false;
set->Content0IsNcch = false;
set->IsBuildingNCCH0 = false;
set->out_format = CIA;
set->CciPath = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-srl") == 0){
if(!HasParam){
PrintNeedsParam("-srl");
return USR_ARG_REQ_PARAM;
}
set->ConvertCci = false;
set->Content0IsSrl = true;
set->Content0IsNcch = false;
set->IsBuildingNCCH0 = false;
set->out_format = CIA;
set->SrlPath = argv[i+1];
return 2;
}
else if(strcmp(argv[i],"-devcardcci") == 0){
if(HasParam){
PrintNoNeedParam("-devcardcci");
return USR_BAD_ARG;
}
set->GenSDKCardInfoHeader = true;
return 1;
}
else if(strcmp(argv[i],"-omitncchhdr") == 0){
if(HasParam){
PrintNoNeedParam("-omitncchhdr");
return USR_BAD_ARG;
}
set->OmitImportedNcchHdr = true;
return 1;
}
else if(strcmp(argv[i],"-cfa") == 0){
if(HasParam){
PrintNoNeedParam("-cfa");
return USR_ARG_REQ_PARAM;
}
set->build_ncch_type = CFA;
return 1;
}
else if(strcmp(argv[i],"-f") == 0){
if(!HasParam){
PrintNeedsParam("-f");
return USR_ARG_REQ_PARAM;
}
if(strcasecmp(argv[i+1],"cxi") == 0 || strcasecmp(argv[i+1],"exec") == 0 ) set->out_format = CXI;
else if(strcasecmp(argv[i+1],"cfa") == 0 || strcasecmp(argv[i+1],"data") == 0 ) set->out_format = CFA;
else if(strcasecmp(argv[i+1],"cci") == 0 || strcasecmp(argv[i+1],"card") == 0 ) set->out_format = CCI;
else if(strcasecmp(argv[i+1],"cia") == 0) set->out_format = CIA;
else {
fprintf(stderr,"[-] Invalid output format '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
return 2;
}
else if(strcmp(argv[i],"-sysfixedkey") == 0){
if(!HasParam){
PrintNeedsParam("-sysfixedkey");
return USR_ARG_REQ_PARAM;
}
if(strlen(argv[i+1]) != 32) {
fprintf(stderr,"[ERROR] Invalid SystemFixedKey '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
u8 *key = malloc(16);
if(!key){
fprintf(stderr,"[ERROR] MEM ERROR\n");
return USR_MEM_ERROR;
}
char_to_u8_array(key,argv[i+1],16,BE,16);
SetSystemFixedKey(&set->keys,key);
free(key);
return 2;
}
else if(strcmp(argv[i],"-commonkey") == 0){
if(!HasParam){
PrintNeedsParam("-commonkey");
return USR_ARG_REQ_PARAM;
}
if(strlen(argv[i+1]) != 32) {
fprintf(stderr,"[ERROR] Invalid CommonKey '%s'\n",argv[i+1]);
return USR_BAD_ARG;
}
u8 *key = malloc(16);
if(!key){
fprintf(stderr,"[ERROR] MEM ERROR\n");
return USR_MEM_ERROR;
}
char_to_u8_array(key,argv[i+1],16,BE,16);
if(i+2 < argc){
u8 id = strtol(argv[i+2],NULL,10);
SetCommonKey(&set->keys,key,id);
SetCurrentCommonKey(&set->keys,id);
}
else SetCommonKey(&set->keys,key,0);
SetCurrentCommonKey(&set->keys,0);
free(key);
return 2;
}
else if(strcmp(argv[i],"-accessdesc") == 0){
if(!HasParam){
PrintNeedsParam("-accessdesc");
return USR_ARG_REQ_PARAM;
}
char *tmp = argv[i+1];
char *tmp2 = strstr(tmp,":");
if(!tmp2){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -accessdesc <APP TYPE>:<TARGET FIRMWARE>\n");
}
if(strlen(tmp2) < 2){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -accessdesc <APP TYPE>:<TARGET FIRMWARE>\n");
}
u32 app_type_len = (u32)(tmp2-tmp);
char *app_type = malloc(app_type_len+1);
memset(app_type,0,app_type_len+1);
memcpy(app_type,tmp,app_type_len);
if(strcasecmp(app_type,"App") == 0 || strcasecmp(app_type,"SDApp") == 0) set->keys.AccessDescSign.PresetType = app;
else if(strcasecmp(app_type,"Demo") == 0) set->keys.AccessDescSign.PresetType = demo;
else if(strcasecmp(app_type,"DlpChild") == 0 || strcasecmp(app_type,"Dlp") == 0) set->keys.AccessDescSign.PresetType = dlp;
else{
fprintf(stderr,"[SETTING ERROR] Accessdesc AppType preset '%s' not valid, please manually configure RSF\n",app_type);
return USR_BAD_ARG;
}
char *target_firmware = (tmp2+1);
set->keys.AccessDescSign.TargetFirmware = strtoul(target_firmware,NULL,10);
return 2;
}
else if(strcmp(argv[i],"-exefslogo") == 0){
if(HasParam){
PrintNoNeedParam("-exefslogo");
return USR_BAD_ARG;
}
set->include_exefs_logo = true;
return 1;
}
else if(strcmp(argv[i],"-rand") == 0){
if(HasParam){
PrintNoNeedParam("-rand");
return USR_BAD_ARG;
}
set->RandomTitleKey = true;
return 1;
}
else if(strcmp(argv[i],"-nocryptcia") == 0){
if(HasParam){
PrintNoNeedParam("-nocryptcia");
return USR_BAD_ARG;
}
set->EncryptContents = false;
return 1;
}
else if(strcmp(argv[i],"-major") == 0){
if(!HasParam){
PrintNeedsParam("-major");
return USR_ARG_REQ_PARAM;
}
u32 tmp = strtoul(argv[i+1],NULL,10);
set->Version[0] = tmp > 63 ? 63 : tmp;
return 2;
}
else if(strcmp(argv[i],"-minor") == 0){
if(!HasParam){
PrintNeedsParam("-minor");
return USR_ARG_REQ_PARAM;
}
u32 tmp = strtoul(argv[i+1],NULL,10);
set->Version[1] = tmp > 63 ? 63 : tmp;
return 2;
}
else if(strcmp(argv[i],"-micro") == 0){
if(!HasParam){
PrintNeedsParam("-micro");
return USR_ARG_REQ_PARAM;
}
u32 tmp = strtoul(argv[i+1],NULL,10);
set->Version[2] = tmp > 15 ? 15 : tmp;
return 2;
}
else if(strcmp(argv[i],"-content") == 0){
if(!HasParam){
PrintNeedsParam("-content");
return USR_ARG_REQ_PARAM;
}
char *pos = strstr(argv[i+1],":");
if(!pos){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -content <CONTENT PATH>:<INDEX>\n");
fprintf(stderr," If generating a CIA, then use the format:\n");
fprintf(stderr," -content <CONTENT PATH>:<INDEX>:<ID>\n");
return USR_BAD_ARG;
}
if(strlen(pos) < 2){
fprintf(stderr,"[SETTING ERROR] Bad argument '%s %s', correct format:\n",argv[i],argv[i+1]);
fprintf(stderr," -content <CONTENT PATH>:<INDEX>\n");
fprintf(stderr," If generating a CIA, then use the format:\n");
fprintf(stderr," -content <CONTENT PATH>:<INDEX>:<ID>\n");
return USR_BAD_ARG;
}
/* Getting Content Index */
u16 content_index = strtol((char*)(pos+1),NULL,10);
/* Storing Content Filepath */
u32 path_len = (u32)(pos-argv[i+1])+1;
if(content_index == 0) set->IsBuildingNCCH0 = false;
if(set->ContentPath[content_index] != NULL){
fprintf(stderr,"[SETTING ERROR] Content %d is already specified\n",content_index);
return USR_BAD_ARG;
}
set->ContentPath[content_index] = malloc(path_len);
if(set->ContentPath[content_index] == NULL){
fprintf(stderr,"[SETTING ERROR] MEM ERROR\n");
return USR_MEM_ERROR;
}
memset(set->ContentPath[content_index],0,path_len);
strncpy(set->ContentPath[content_index],argv[i+1],path_len-1);
/* Get ContentID for CIA gen */
char *pos2 = strstr(pos+1,":");
if(pos2) {
set->ContentID[content_index] = strtoul((pos2+1),NULL,16);
}
/* Return Next Arg Pos*/
return 2;
}
/*
else if(strncmp(argv[i],"-D",2) == 0){
fprintf(stderr,"[WARNING] -DNAME=VALUE not implemented yet\n");
}
*/
// If not a valid argument
fprintf(stderr,"[SETTING ERROR] Unrecognised argument '%s'\n",argv[i]);
return USR_UNK_ARG;
}
int CheckArgumentCombination(user_settings *set)
{
for(int i = 0; i < CIA_MAX_CONTENT; i++){
if( i > CCI_MAX_CONTENT-1 && set->ContentPath[i] && set->out_format == CCI){
fprintf(stderr,"[SETTING ERROR] Content indexes > 7 are invalid for CCI\n");
return USR_BAD_ARG;
}
if(set->ContentPath[i] && (set->out_format == CXI || set->out_format == CFA)){
fprintf(stderr,"[SETTING ERROR] You cannot specify content while outputting CXI/CFA files\n");
return USR_BAD_ARG;
}
}
if((set->out_format == CXI || set->out_format == CFA) && set->build_ncch_type > 0){
fprintf(stderr,"[SETTING ERROR] Arguments '-f cxi|cfa' and '-ncch cxi|cfa' are invalid\n");
return USR_BAD_ARG;
}
if(set->build_ncch_type > 0 && !set->IsBuildingNCCH0){
fprintf(stderr,"[SETTING ERROR] Arguments '-content %s:0' and '-ncch cxi|cfa' cannot be used together\n",set->ContentPath[0]);
return USR_BAD_ARG;
}
if(set->elf_path && set->exefs_code_path){
fprintf(stderr,"[SETTING ERROR] Arguments '-elf' and '-code' cannot be used together\n");
return USR_BAD_ARG;
}
// Setting set->build_ncch_type if it isn't already set
if(set->IsBuildingNCCH0 && set->build_ncch_type == 0){
if(set->out_format == CCI || set->out_format == CIA) set->build_ncch_type = CXI;
else set->build_ncch_type = set->out_format;
}
bool buildCXI = (set->out_format == CXI || set->build_ncch_type == CXI) && set->IsBuildingNCCH0;
bool buildCFA = (set->out_format == CFA || set->build_ncch_type == CFA) && set->IsBuildingNCCH0;
// Detecting Required Arguments
if(buildCXI && !set->elf_path && !set->exefs_code_path){
PrintNeedsArgument("-elf");
return USR_BAD_ARG;
}
if((buildCXI || buildCFA) && !set->rsf_path){
PrintNeedsArgument("-rsf");
return USR_BAD_ARG;
}
if(buildCXI && !set->exheader_path && set->exefs_code_path){
PrintNeedsArgument("-exheader");
return USR_BAD_ARG;
}
// Reporting bad arguments
if(!buildCXI && set->elf_path){
PrintArgumentInvalid("-elf");
return USR_BAD_ARG;
}
if(!buildCXI && set->exefs_code_path){
PrintArgumentInvalid("-code");
return USR_BAD_ARG;
}
if(!buildCXI && set->exheader_path){
PrintArgumentInvalid("-exheader");
return USR_BAD_ARG;
}
if(!buildCXI && set->plain_region_path){
PrintArgumentInvalid("-plain-region");
return USR_BAD_ARG;
}
if(!buildCXI && set->include_exefs_logo){
PrintArgumentInvalid("-exefslogo");
return USR_BAD_ARG;
}
if(!set->IsBuildingNCCH0 && set->romfs_path){
PrintArgumentInvalid("-romfs");
return USR_BAD_ARG;
}
return 0;
}
void init_UserSettings(user_settings *usr_settings)
{
memset(usr_settings,0,sizeof(user_settings));
}
void free_RsfSettings(rsf_settings *set)
{
//Option
free(set->Option.PageSize);
for(u32 i = 0; i < set->Option.AppendSystemCallNum; i++){
free(set->Option.AppendSystemCall[i]);
}
free(set->Option.AppendSystemCall);
//AccessControlInfo
free(set->AccessControlInfo.ProgramId);
free(set->AccessControlInfo.IdealProcessor);
free(set->AccessControlInfo.Priority);
free(set->AccessControlInfo.MemoryType);
free(set->AccessControlInfo.SystemMode);
free(set->AccessControlInfo.CoreVersion);
free(set->AccessControlInfo.HandleTableSize);
free(set->AccessControlInfo.SystemSaveDataId1);
free(set->AccessControlInfo.SystemSaveDataId2);
free(set->AccessControlInfo.OtherUserSaveDataId1);
free(set->AccessControlInfo.OtherUserSaveDataId2);
free(set->AccessControlInfo.OtherUserSaveDataId3);
free(set->AccessControlInfo.ExtSaveDataId);
free(set->AccessControlInfo.SystemMode);
free(set->AccessControlInfo.AffinityMask);
free(set->AccessControlInfo.DescVersion);
free(set->AccessControlInfo.CryptoKey);
free(set->AccessControlInfo.ResourceLimitCategory);
free(set->AccessControlInfo.ReleaseKernelMajor);
free(set->AccessControlInfo.ReleaseKernelMinor);
free(set->AccessControlInfo.MaxCpu);
for(u32 i = 0; i < set->AccessControlInfo.MemoryMappingNum; i++){
free(set->AccessControlInfo.MemoryMapping[i]);
}
free(set->AccessControlInfo.MemoryMapping);
for(u32 i = 0; i < set->AccessControlInfo.IORegisterMappingNum; i++){
free(set->AccessControlInfo.IORegisterMapping[i]);
}
free(set->AccessControlInfo.IORegisterMapping);
for(u32 i = 0; i < set->AccessControlInfo.FileSystemAccessNum; i++){
free(set->AccessControlInfo.FileSystemAccess[i]);
}
free(set->AccessControlInfo.FileSystemAccess);
for(u32 i = 0; i < set->AccessControlInfo.IoAccessControlNum; i++){
free(set->AccessControlInfo.IoAccessControl[i]);
}
free(set->AccessControlInfo.IoAccessControl);
for(u32 i = 0; i < set->AccessControlInfo.InterruptNumbersNum; i++){
free(set->AccessControlInfo.InterruptNumbers[i]);
}
free(set->AccessControlInfo.InterruptNumbers);
for(u32 i = 0; i < set->AccessControlInfo.SystemCallAccessNum; i++){
free(set->AccessControlInfo.SystemCallAccess[i]);
}
free(set->AccessControlInfo.SystemCallAccess);
for(u32 i = 0; i < set->AccessControlInfo.ServiceAccessControlNum; i++){
free(set->AccessControlInfo.ServiceAccessControl[i]);
}
free(set->AccessControlInfo.ServiceAccessControl);
for(u32 i = 0; i < set->AccessControlInfo.StorageIdNum; i++){
free(set->AccessControlInfo.StorageId[i]);
}
free(set->AccessControlInfo.StorageId);
for(u32 i = 0; i < set->AccessControlInfo.AccessibleSaveDataIdsNum; i++){
free(set->AccessControlInfo.AccessibleSaveDataIds[i]);
}
free(set->AccessControlInfo.AccessibleSaveDataIds);
//SystemControlInfo
free(set->SystemControlInfo.AppType);
free(set->SystemControlInfo.StackSize);
free(set->SystemControlInfo.RemasterVersion);
free(set->SystemControlInfo.JumpId);
for(u32 i = 0; i < set->SystemControlInfo.DependencyNum; i++){
free(set->SystemControlInfo.Dependency[i]);
}
free(set->SystemControlInfo.Dependency);
//BasicInfo
free(set->BasicInfo.Title);
free(set->BasicInfo.CompanyCode);
free(set->BasicInfo.ProductCode);
free(set->BasicInfo.MediaSize);
free(set->BasicInfo.ContentType);
free(set->BasicInfo.Logo);
free(set->BasicInfo.BackupMemoryType);
free(set->BasicInfo.InitialCode);
//Rom
free(set->Rom.HostRoot);
free(set->Rom.Padding);
free(set->Rom.SaveDataSize);
for(u32 i = 0; i < set->Rom.DefaultRejectNum; i++){
free(set->Rom.DefaultReject[i]);
}
free(set->Rom.DefaultReject);
for(u32 i = 0; i < set->Rom.RejectNum; i++){
free(set->Rom.Reject[i]);
}
free(set->Rom.Reject);
for(u32 i = 0; i < set->Rom.IncludeNum; i++){
free(set->Rom.Include[i]);
}
free(set->Rom.Include);
for(u32 i = 0; i < set->Rom.FileNum; i++){
free(set->Rom.File[i]);
}
free(set->Rom.File);
//ExeFs
for(u32 i = 0; i < set->ExeFs.TextNum; i++){
free(set->ExeFs.Text[i]);
}
free(set->ExeFs.Text);
for(u32 i = 0; i < set->ExeFs.ReadOnlyNum; i++){
free(set->ExeFs.ReadOnly[i]);
}
free(set->ExeFs.ReadOnly);
for(u32 i = 0; i < set->ExeFs.ReadWriteNum; i++){
free(set->ExeFs.ReadWrite[i]);
}
free(set->ExeFs.ReadWrite);
//PlainRegion
for(u32 i = 0; i < set->PlainRegionNum; i++){
free(set->PlainRegion[i]);
}
free(set->PlainRegion);
//TitleInfo
free(set->TitleInfo.Platform);
free(set->TitleInfo.Category);
free(set->TitleInfo.UniqueId);
free(set->TitleInfo.Version);
free(set->TitleInfo.ContentsIndex);
free(set->TitleInfo.Variation);
free(set->TitleInfo.Use);
free(set->TitleInfo.ChildIndex);
free(set->TitleInfo.DemoIndex);
free(set->TitleInfo.TargetCategory);
for(u32 i = 0; i < set->TitleInfo.CategoryFlagsNum; i++){
free(set->TitleInfo.CategoryFlags[i]);
}
free(set->TitleInfo.CategoryFlags);
//CardInfo
free(set->CardInfo.WritableAddress);
free(set->CardInfo.CardType);
free(set->CardInfo.CryptoType);
free(set->CardInfo.CardDevice);
free(set->CardInfo.MediaType);
free(set->CardInfo.BackupWriteWaitTime);
//CommonHeaderKey
free(set->CommonHeaderKey.D);
free(set->CommonHeaderKey.P);
free(set->CommonHeaderKey.Q);
free(set->CommonHeaderKey.DP);
free(set->CommonHeaderKey.DQ);
free(set->CommonHeaderKey.InverseQ);
free(set->CommonHeaderKey.Modulus);
free(set->CommonHeaderKey.Exponent);
free(set->CommonHeaderKey.AccCtlDescSign);
free(set->CommonHeaderKey.AccCtlDescBin);
}
void free_UserSettings(user_settings *usr_settings)
{
// Free Content Paths
if(usr_settings->ContentPath){
for(int i = 0; i < CIA_MAX_CONTENT; i++){
free(usr_settings->ContentPath[i]);
}
free(usr_settings->ContentPath);
}
// Free Spec File Setting
free_RsfSettings(&usr_settings->yaml_set);
// Free Key Data
FreeKeys(&usr_settings->keys);
// Free Content0
free(usr_settings->Content0.buffer);
// Free outfile path, if malloc'd
if(usr_settings->outfile_mallocd) free(usr_settings->outfile);
// Clear settings
init_UserSettings(usr_settings);
// Free
free(usr_settings);
}
void PrintNeedsArgument(char *arg)
{
fprintf(stderr,"[SETTING ERROR] Argument '%s' is required\n",arg);
}
void PrintArgumentInvalid(char *arg)
{
fprintf(stderr,"[SETTING ERROR] Argument '%s' is invalid\n",arg);
}
void PrintNeedsParam(char *arg)
{
fprintf(stderr,"[SETTING ERROR] '%s' requires a parameter\n",arg);
}
void PrintNoNeedParam(char *arg)
{
fprintf(stderr,"[SETTING ERROR] '%s' does not take a parameter\n",arg);
}
void DisplayHelp(char *app_name)
{
printf("CTR MAKEROM %d.%d",MAKEROM_VER_MAJOR,MAKEROM_VER_MINOR);
#ifndef PUBLIC_BUILD
printf(" PRIVATE BUILD");
#endif
printf("\n(C) 3DSGuy 2014\n");
printf("Usage: %s [options... ]\n",app_name);
printf("Option Parameter Explanation\n");
printf("GLOBAL OPTIONS:\n");
printf(" -help Display this text\n");
printf(" -rsf <rsf path> RSF File\n");
printf(" -f <out format> Output Format (cxi|cfa|cci|cia)\n");
printf(" -o <outfile> Output File\n");
//printf(" -v Verbose\n");
//printf(" -DNAME=VALUE Substitute values in Spec files\n");
printf("KEY OPTIONS:\n");
printf(" -sysfixedkey <32 hex chars> Specify SystemFixed Key\n");
printf(" -commonkey <32 hex chars> <id> Specify commonkey and index\n");
#ifndef PUBLIC_BUILD
printf(" -target <value> Debug or Retail(Default)\n");
#endif
printf("NCCH OPTIONS:\n");
printf(" -elf <elf path> ELF File\n");
printf(" -icon <icon path> Icon File\n");
printf(" -banner <banner path> Banner File\n");
printf(" -logo <logo path> Logo File (Overrides \"BasicInfo/Logo\" in RSF)\n");
printf(" -accessdesc <apptype>:<fw> Specify AccessDesc Preset\n");
printf(" -exefslogo Include Logo in ExeFs (Required for usage on <5.X Systems)\n");
printf(" -cfa Specify if building a Data Archive when \"-f cia\"\n");
printf("NCCH REBUILD OPTIONS:\n");
printf(" -code <code path> Specify ExeFs code File\n");
printf(" -exheader <exhdr path> ExHeader Template File\n");
printf(" -plain-region <pln region path> PlainRegion File\n");
printf(" -romfs <romfs path> RomFS File\n");
printf("CCI OPTIONS:\n");
#ifndef PUBLIC_BUILD
printf(" -devcardcci Use SDK CardInfo Method\n");
printf(" -omitncchhdr Omit NCCH Hdr for imported NCCH0\n");
#endif
printf(" -content <filepath>:<index> Specify content files\n");
printf("CIA OPTIONS:\n");
#ifndef PUBLIC_BUILD
printf(" -cci <cci path> Convert CCI to CIA\n");
printf(" -srl <srl path> Use TWL SRL as Content0\n");
#endif
printf(" -content <filepath>:<index>:<id> Specify content files\n");
printf(" -major <version major> Specify Title Version Major\n");
printf(" -minor <version minor> Specify Title Version Minor\n");
printf(" -micro <version micro> Specify Title Version Micro\n");
printf(" -rand Use a random title key\n");
printf(" -nocryptcia Don't encrypt CIA contents\n");
}
usersettings.h
-265
View File
@@ -1,265 +0,0 @@
#ifndef _USERSETTINGS_H_
#define _USERSETTINGS_H_
#define CCI_MAX_CONTENT 8
#define CIA_MAX_CONTENT 65536
typedef enum
{
USR_PTR_PASS_FAIL = -1,
USR_HELP = -2,
USR_ARG_REQ_PARAM = -3,
USR_UNK_ARG = -4,
USR_BAD_ARG = -5,
USR_MEM_ERROR = -6,
} user_settings_errors;
typedef enum
{
format_not_set,
CXI,
CFA,
CCI,
CIA
} output_format;
static const char output_extention[4][5] = {".cxi",".cfa",".cci",".cia"};
typedef struct
{
struct{
// Booleans
bool NoPadding; // DELETE
bool AllowUnalignedSection;
bool EnableCrypt;
bool EnableCompress;
bool FreeProductCode;
bool UseOnSD;
// Strings
char *PageSize;
// String Collections
u32 AppendSystemCallNum; // DELETE
char **AppendSystemCall; // DELETE
} Option;
struct{
// Booleans
bool DisableDebug;
bool EnableForceDebug;
bool CanWriteSharedPage;
bool CanUsePrivilegedPriority;
bool CanUseNonAlphabetAndNumber;
bool PermitMainFunctionArgument;
bool CanShareDeviceMemory;
bool UseOtherVariationSaveData;
bool UseExtSaveData;
bool UseExtendedSaveDataAccessControl;
bool RunnableOnSleep;
bool SpecialMemoryArrange;
// Strings
char *ProgramId; // DELETE
char *IdealProcessor;
char *Priority;
char *MemoryType;
char *SystemMode;
char *CoreVersion;
char *HandleTableSize;
char *SystemSaveDataId1;
char *SystemSaveDataId2;
char *OtherUserSaveDataId1;
char *OtherUserSaveDataId2;
char *OtherUserSaveDataId3;
char *ExtSaveDataId;
char *AffinityMask;
// Strings From DESC
char *DescVersion;
char *CryptoKey; // DELETE
char *ResourceLimitCategory;
char *ReleaseKernelMajor;
char *ReleaseKernelMinor;
char *MaxCpu;
// String Collections
u32 MemoryMappingNum;
char **MemoryMapping;
u32 IORegisterMappingNum;
char **IORegisterMapping;
u32 FileSystemAccessNum;
char **FileSystemAccess;
u32 IoAccessControlNum;
char **IoAccessControl; //Equiv to Arm9AccessControl
u32 InterruptNumbersNum;
char **InterruptNumbers;
u32 SystemCallAccessNum;
char **SystemCallAccess;
u32 ServiceAccessControlNum;
char **ServiceAccessControl;
u32 StorageIdNum; // DELETE
char **StorageId; // DELETE
u32 AccessibleSaveDataIdsNum;
char **AccessibleSaveDataIds;
} AccessControlInfo;
struct{
// Strings
char *AppType;
char *StackSize;
char *RemasterVersion;
char *JumpId;
// String Collections
u32 DependencyNum;
char **Dependency;
} SystemControlInfo;
struct{
// Booleans
bool MediaFootPadding;
// Strings
char *Title;
char *CompanyCode;
char *ProductCode;
char *MediaSize;
char *ContentType;
char *Logo;
char *BackupMemoryType;// Delete
char *InitialCode;// Delete
} BasicInfo;
struct{
// Strings
char *HostRoot;
char *Padding; // DELETE
char *SaveDataSize;
// String Collections
u32 DefaultRejectNum;
char **DefaultReject;
u32 RejectNum;
char **Reject;
u32 IncludeNum;
char **Include;
u32 FileNum;
char **File;
} Rom;
struct{
u32 TextNum;
char **Text;
u32 ReadOnlyNum;
char **ReadOnly;
u32 ReadWriteNum;
char **ReadWrite;
} ExeFs;
u32 PlainRegionNum;
char **PlainRegion;
struct{
// Strings
char *Platform; // DELETE
char *Category;
char *UniqueId;
char *Version;
char *ContentsIndex;
char *Variation;
char *Use; // DELETE
char *ChildIndex;
char *DemoIndex;
char *TargetCategory;
// String Collections
u32 CategoryFlagsNum;
char **CategoryFlags;
} TitleInfo;
struct{
char *WritableAddress;
char *CardType;
char *CryptoType;
char *CardDevice;
char *MediaType;
char *BackupWriteWaitTime;
} CardInfo;
struct{
bool Found;
char *D;
char *P;
char *Q;
char *DP;
char *DQ;
char *InverseQ;
char *Modulus;
char *Exponent;
char *AccCtlDescSign;
char *AccCtlDescBin;
} CommonHeaderKey;
} rsf_settings;
typedef struct
{
// General Settings
char *rsf_path;
bool outfile_mallocd;
char *outfile;
output_format out_format;
// Content0
bool ConvertCci;
char *CciPath;
bool Content0IsSrl;
char *SrlPath;
bool Content0IsNcch;
COMPONENT_STRUCT Content0;
char **ContentPath;
u64 ContentID[CIA_MAX_CONTENT]; // For CIA
// Ncch0 Build
bool IsBuildingNCCH0;
output_format build_ncch_type;
char *elf_path;
char *icon_path;
char *banner_path;
char *logo_path;
bool include_exefs_logo;
char *exefs_code_path;
char *exheader_path;
char *plain_region_path;
char *romfs_path;
// CCI Settings
bool GenSDKCardInfoHeader;
bool OmitImportedNcchHdr;
// CIA Settings
bool RandomTitleKey;
bool EncryptContents;
u16 Version[3];
// Keys
keys_struct keys;
// RSF/DESC Imported Settings
rsf_settings yaml_set;
} user_settings;
#endif
// Prototypes
void init_UserSettings(user_settings *usr_settings);
void free_UserSettings(user_settings *usr_settings);
int ParseArgs(int argc, char *argv[], user_settings *usr_settings);
void ReadYAMLtest(char *filepath);
void free_RsfSettings(rsf_settings *set);
utils.c
-373
View File
@@ -1,373 +0,0 @@
#include "lib.h"
//MISC
void char_to_u8_array(unsigned char destination[], char source[], int size, int endianness, int base)
{
char tmp[size][2];
unsigned char *byte_array = malloc(size*sizeof(unsigned char));
memset(byte_array, 0, size);
memset(destination, 0, size);
memset(tmp, 0, size*2);
for (int i = 0; i < size; i ++){
tmp[i][0] = source[(i*2)];
tmp[i][1] = source[((i*2)+1)];
tmp[i][2] = '\0';
byte_array[i] = (unsigned char)strtol(tmp[i], NULL, base);
}
endian_memcpy(destination,byte_array,size,endianness);
free(byte_array);
}
void endian_memcpy(u8 *destination, u8 *source, u32 size, int endianness)
{
for (u32 i = 0; i < size; i++){
switch (endianness){
case(BE):
destination[i] = source[i];
break;
case(LE):
destination[i] = source[((size-1)-i)];
break;
}
}
}
void u8_hex_print_be(u8 *array, int len)
{
for(int i = 0; i < len; i++)
printf("%02x",array[i]);
}
void u8_hex_print_le(u8 *array, int len)
{
for(int i = 0; i < len; i++)
printf("%02x",array[len - i - 1]);
}
u64 align_value(u64 value, u64 alignment)
{
u64 tmp = value;
while(tmp > alignment)
tmp -= alignment;
return (value + (alignment - tmp));
}
void resolve_flag(unsigned char flag, unsigned char *flag_bool)
{
unsigned char bit_mask[8] = {0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x1};
for(int i = 0; i < 8; i++){
if (flag >= bit_mask[i]){
flag_bool[7-i] = true;
flag -= bit_mask[i];
}
else
flag_bool[7-i] = false;
}
}
void resolve_flag_u16(u16 flag, unsigned char *flag_bool)
{
u16 bit_mask[16] = {0x8000,0x4000,0x2000,0x1000,0x800,0x400,0x200,0x100,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x1};
for(int i = 0; i < 16; i++){
if (flag >= bit_mask[i]){
flag_bool[15-i] = true;
flag -= bit_mask[i];
}
else
flag_bool[15-i] = false;
}
}
int append_filextention(char *output, u16 max_outlen, char *input, char extention[])
{
if(output == NULL || input == NULL){
printf("[!] Memory Error\n");
return Fail;
}
memset(output,0,max_outlen);
u16 extention_point = strlen(input)+1;
for(int i = strlen(input)-1; i > 0; i--){
if(input[i] == '.'){
extention_point = i;
break;
}
}
if(extention_point+strlen(extention) >= max_outlen){
printf("[!] Input File Name Too Large for Output buffer\n");
return Fail;
}
memcpy(output,input,extention_point);
sprintf(output,"%s%s",output,extention);
return 0;
}
int CopyData(u8 **dest, u8 *source, u64 size)
{
if(!*dest){
*dest = malloc(size);
if(!*dest) return -1;
}
memcpy(*dest,source,size);
return 0;
}
u64 min_u64(u64 a, u64 b)
{
if(a < b) return a;
return b;
}
u64 max_u64(u64 a, u64 b)
{
if(a > b) return a;
return b;
}
//IO Related
void WriteBuffer(void *buffer, u64 size, u64 offset, FILE *output)
{
fseek_64(output,offset,SEEK_SET);
fwrite(buffer,size,1,output);
}
void ReadFile_64(void *outbuff, u64 size, u64 offset, FILE *file)
{
fseek_64(file,offset,SEEK_SET);
fread(outbuff,size,1,file);
}
u64 GetFileSize_u64(char *filename)
{
u64 size;
#ifdef _WIN32
/* Making sure file exists */
FILE *tmp = fopen(filename,"rb");
if(!tmp) return 0;
fclose(tmp);
int fh;
u64 n;
fh = _open( filename, 0 );
n = _lseeki64(fh, 0, SEEK_END);
_close(fh);
size = (n / sizeof(short))*2;
#else
FILE *file = fopen(filename,"rb");
fseeko(file, 0L, SEEK_END);
size = ftello(file);
fclose(file);
#endif
return size;
}
u32 GetFileSize_u32(FILE *file)
{
u32 size = 0;
fseek(file, 0L, SEEK_END);
size = ftell(file);
fseek(file, 0L, SEEK_SET);
return size;
}
int TruncateFile_u64(char *filename, u64 filelen)
{
#ifdef _WIN32
HANDLE fh;
LARGE_INTEGER fp;
fp.QuadPart = filelen;
fh = CreateFile(filename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if (fh == INVALID_HANDLE_VALUE) {
printf("[!] Invalid File handle\n");
return 1;
}
if (SetFilePointerEx(fh, fp, NULL, FILE_BEGIN) == 0 ||
SetEndOfFile(fh) == 0) {
printf("[!] truncate failed\n");
CloseHandle(fh);
return 1;
}
CloseHandle(fh);
return 0;
#else
return truncate(filename,filelen);
#endif
}
int fseek_64(FILE *fp, u64 file_pos, int whence)
{
#ifdef _WIN32
if(whence != SEEK_SET)
printf("[!] fseek_64, whence has been overided to SEEK_SET\n");
fpos_t pos = file_pos;
return fsetpos(fp,&pos); //I can't believe the 2gb problem with Windows & MINGW, maybe I have a bad installation :/
#else
return fseeko(fp,file_pos,whence);
#endif
}
int makedir(const char* dir)
{
#ifdef _WIN32
return _mkdir(dir);
#else
return mkdir(dir, 0777);
#endif
}
char *getcwdir(char *buffer,int maxlen)
{
#ifdef _WIN32
return _getcwd(buffer,maxlen);
#else
return getcwd(buffer,maxlen);
#endif
}
//Data Size conversion
u16 u8_to_u16(u8 *value, u8 endianness)
{
u16 new_value;
switch(endianness){
case(BE): new_value = (value[1]<<0) | (value[0]<<8); break;
case(LE): new_value = (value[0]<<0) | (value[1]<<8); break;
}
return new_value;
}
u32 u8_to_u32(u8 *value, u8 endianness)
{
u32 new_value;
switch(endianness){
case(BE): new_value = (value[3]<<0) | (value[2]<<8) | (value[1]<<16) | (value[0]<<24); break;
case(LE): new_value = (value[0]<<0) | (value[1]<<8) | (value[2]<<16) | (value[3]<<24); break;
}
return new_value;
}
u64 u8_to_u64(u8 *value, u8 endianness)
{
u64 u64_return = 0;
switch(endianness){
case(BE):
u64_return |= (u64)value[7]<<0;
u64_return |= (u64)value[6]<<8;
u64_return |= (u64)value[5]<<16;
u64_return |= (u64)value[4]<<24;
u64_return |= (u64)value[3]<<32;
u64_return |= (u64)value[2]<<40;
u64_return |= (u64)value[1]<<48;
u64_return |= (u64)value[0]<<56;
break;
//return (value[7]<<0) | (value[6]<<8) | (value[5]<<16) | (value[4]<<24) | (value[3]<<32) | (value[2]<<40) | (value[1]<<48) | (value[0]<<56);
case(LE):
u64_return |= (u64)value[0]<<0;
u64_return |= (u64)value[1]<<8;
u64_return |= (u64)value[2]<<16;
u64_return |= (u64)value[3]<<24;
u64_return |= (u64)value[4]<<32;
u64_return |= (u64)value[5]<<40;
u64_return |= (u64)value[6]<<48;
u64_return |= (u64)value[7]<<56;
break;
//return (value[0]<<0) | (value[1]<<8) | (value[2]<<16) | (value[3]<<24) | (value[4]<<32) | (value[5]<<40) | (value[6]<<48) | (value[7]<<56);
}
return u64_return;
}
int u16_to_u8(u8 *out_value, u16 in_value, u8 endianness)
{
switch(endianness){
case(BE):
out_value[0]=(in_value >> 8);
out_value[1]=(in_value >> 0);
break;
case(LE):
out_value[0]=(in_value >> 0);
out_value[1]=(in_value >> 8);
break;
}
return 0;
}
int u32_to_u8(u8 *out_value, u32 in_value, u8 endianness)
{
switch(endianness){
case(BE):
out_value[0]=(in_value >> 24);
out_value[1]=(in_value >> 16);
out_value[2]=(in_value >> 8);
out_value[3]=(in_value >> 0);
break;
case(LE):
out_value[0]=(in_value >> 0);
out_value[1]=(in_value >> 8);
out_value[2]=(in_value >> 16);
out_value[3]=(in_value >> 24);
break;
}
return 0;
}
int u64_to_u8(u8 *out_value, u64 in_value, u8 endianness)
{
switch(endianness){
case(BE):
out_value[0]=(in_value >> 56);
out_value[1]=(in_value >> 48);
out_value[2]=(in_value >> 40);
out_value[3]=(in_value >> 32);
out_value[4]=(in_value >> 24);
out_value[5]=(in_value >> 16);
out_value[6]=(in_value >> 8);
out_value[7]=(in_value >> 0);
break;
case(LE):
out_value[0]=(in_value >> 0);
out_value[1]=(in_value >> 8);
out_value[2]=(in_value >> 16);
out_value[3]=(in_value >> 24);
out_value[4]=(in_value >> 32);
out_value[5]=(in_value >> 40);
out_value[6]=(in_value >> 48);
out_value[7]=(in_value >> 56);
break;
}
return 0;
}
//Copied from ctrtool
void memdump(FILE* fout, const char* prefix, const u8* data, u32 size)
{
u32 i;
u32 prefixlen = strlen(prefix);
u32 offs = 0;
u32 line = 0;
while(size)
{
u32 max = 32;
if (max > size)
max = size;
if (line==0)
fprintf(fout, "%s", prefix);
else
fprintf(fout, "%*s", prefixlen, "");
for(i=0; i<max; i++)
fprintf(fout, "%02X", data[offs+i]);
fprintf(fout, "\n");
line++;
size -= max;
offs += max;
}
}
utils.h
-46
View File
@@ -1,46 +0,0 @@
#ifndef _UTILS_H_
#define _UTILS_H_
typedef struct
{
char *argument;
u16 arg_len;
} OPTION_CTX;
typedef struct
{
u64 size;
u8 *buffer;
} COMPONENT_STRUCT;
#endif
//MISC
void char_to_u8_array(unsigned char destination[], char source[], int size, int endianness, int base);
void endian_memcpy(u8 *destination, u8 *source, u32 size, int endianness);
void u8_hex_print_be(u8 *array, int len);
void u8_hex_print_le(u8 *array, int len);
u64 align_value(u64 value, u64 alignment);
void resolve_flag(unsigned char flag, unsigned char *flag_bool);
void resolve_flag_u16(u16 flag, unsigned char *flag_bool);
int append_filextention(char *output, u16 max_outlen, char *input, char extention[]);
int CopyData(u8 **dest, u8 *source, u64 size);
u64 min_u64(u64 a, u64 b);
u64 max_u64(u64 a, u64 b);
//IO Related
void WriteBuffer(void *buffer, u64 size, u64 offset, FILE *output);
void ReadFile_64(void *outbuff, u64 size, u64 offset, FILE *file);
u64 GetFileSize_u64(char *filename);
u32 GetFileSize_u32(FILE *file);
int TruncateFile_u64(char *filename, u64 filelen);
int fseek_64(FILE *fp, u64 file_pos, int whence);
int makedir(const char* dir);
char *getcwdir(char *buffer,int maxlen);
//Data Size conversion
u16 u8_to_u16(u8 *value, u8 endianness);
u32 u8_to_u32(u8 *value, u8 endianness);
u64 u8_to_u64(u8 *value, u8 endianness);
int u16_to_u8(u8 *out_value, u16 in_value, u8 endianness);
int u32_to_u8(u8 *out_value, u32 in_value, u8 endianness);
int u64_to_u8(u8 *out_value, u64 in_value, u8 endianness);
//from ctrtool
void memdump(FILE* fout, const char* prefix, const u8* data, u32 size);
yaml_ctr.c
-437
View File
@@ -1,437 +0,0 @@
#include "lib.h"
#include "yamlsettings.h"
// Private Prototypes
void InitYamlContext(ctr_yaml_context *ctx);
int ParseSpecFile(rsf_settings *set, char *path);
void CheckEvent(ctr_yaml_context *ctx);
void BadYamlFormatting(void);
// Code
int GetYamlSettings(user_settings *set)
{
memset(&set->yaml_set,0,sizeof(rsf_settings));
int ret = 0;
if(set->rsf_path) {
FILE *tmp = fopen(set->rsf_path,"rb");
if(!tmp) {
fprintf(stderr,"[YAML ERROR] Failed to open %s\n",set->rsf_path);
return FAILED_TO_OPEN_FILE;
}
fclose(tmp);
ret = ParseSpecFile(&set->yaml_set,set->rsf_path);
}
return ret;
}
int ParseSpecFile(rsf_settings *set, char *path)
{
ctr_yaml_context *ctx = malloc(sizeof(ctr_yaml_context));
InitYamlContext(ctx);
/* Set Specfile Type */
/* Create the Parser object. */
yaml_parser_initialize(&ctx->parser);
/* Set a file input. */
FILE *input = fopen(path,"rb");
yaml_parser_set_input_file(&ctx->parser, input);
ctx->IsSequence = false;
ctx->IsKey = true;
ctx->prev_event = 0;
ctx->Level = 0;
/* Read the event sequence. */
while (!ctx->done) {
/* Get the next event. */
GetEvent(ctx);
if(ctx->error) goto error;
/* Proccess Event */
if(EventIsScalar(ctx)){
EvaluateRSF(set,ctx);
if(ctx->error) goto error;
break;
}
/*
if((ctx->event.type == YAML_SEQUENCE_START_EVENT|| ctx->event.type == YAML_MAPPING_START_EVENT) && ctx->prev_event == YAML_SCALAR_EVENT) printf(":\n");
if(ctx->event.type == YAML_SCALAR_EVENT){
if(ctx->IsSequence){
printf(" - %s\n",ctx->event.data.scalar.value);
}
else{
if(!ctx->IsKey) printf(": %s\n",ctx->event.data.scalar.value);
else printf("%s",ctx->event.data.scalar.value);
}
}
*/
/* Finish Event */
FinishEvent(ctx);
if(ctx->error) goto error;
}
/* Destroy the Parser object. */
yaml_parser_delete(&ctx->parser);
fclose(input);
return 0;
/* On error. */
error:
fprintf(stderr,"[-] Error Proccessing RSF file\n");
/* Destroy the Parser object. */
yaml_parser_delete(&ctx->parser);
fclose(input);
return ctx->error;
}
void InitYamlContext(ctr_yaml_context *ctx)
{
memset(ctx,0,sizeof(ctr_yaml_context));
}
char *GetYamlString(ctr_yaml_context *ctx)
{
/*
if(EventIsScalar(ctx)){
if(!GetYamlStringSize(ctx) && !ctx->event.data.scalar.value)
return ctx->event.data.scalar.value;
}
return NULL;
*/
return (char*)ctx->event.data.scalar.value;
}
u32 GetYamlStringSize(ctr_yaml_context *ctx)
{
return ctx->event.data.scalar.length;
}
void GetEvent(ctr_yaml_context *ctx)
{
if (!yaml_parser_parse(&ctx->parser, &ctx->event)){
ctx->error = YAML_API_ERROR;
return;
}
CheckEvent(ctx);
}
void CheckEvent(ctr_yaml_context *ctx)
{
switch(ctx->event.type){
case YAML_SEQUENCE_START_EVENT:
ctx->IsSequence = true;
ctx->IsKey = true;
ctx->Level++;
//printf("[LEVEL] %d\n",ctx->Level);
break;
case YAML_SEQUENCE_END_EVENT:
ctx->IsSequence = false;
ctx->IsKey = true;
ctx->Level--;
//printf("[LEVEL] %d\n",ctx->Level);
break;
case YAML_MAPPING_START_EVENT:
ctx->IsKey = true;
ctx->Level++;
//printf("[LEVEL] %d\n",ctx->Level);
break;
case YAML_MAPPING_END_EVENT:
ctx->IsKey = true;
ctx->Level--;
//printf("[LEVEL] %d\n",ctx->Level);
break;
case YAML_DOCUMENT_END_EVENT:
case YAML_STREAM_END_EVENT:
ctx->done = true;
break;
default: break;
}
}
void FinishEvent(ctr_yaml_context *ctx)
{
if(ctx->event.type == YAML_SCALAR_EVENT) {
if(!ctx->IsSequence){
if(!ctx->IsKey)ctx->IsKey = true;
else ctx->IsKey = false;
}
}
ctx->prev_event = ctx->event.type;
yaml_event_delete(&ctx->event);
}
bool EventIsScalar(ctr_yaml_context *ctx)
{
return (ctx->event.type == YAML_SCALAR_EVENT);
}
bool EventIsMappingStart(ctr_yaml_context *ctx)
{
return (ctx->event.type == YAML_MAPPING_START_EVENT);
}
bool EventIsMappingEnd(ctr_yaml_context *ctx)
{
return (ctx->event.type == YAML_MAPPING_END_EVENT);
}
bool EventIsSequenceStart(ctr_yaml_context *ctx)
{
return (ctx->event.type == YAML_SEQUENCE_START_EVENT);
}
bool EventIsSequenceEnd(ctr_yaml_context *ctx)
{
return (ctx->event.type == YAML_SEQUENCE_END_EVENT);
}
bool CheckSequenceEvent(ctr_yaml_context *ctx)
{
GetEvent(ctx);
if(!EventIsSequenceStart(ctx)){
FinishEvent(ctx);
//fprintf(stderr,"[-] Bad formatting in Spec file (Expected Sequence)\n");
//ctx->error = YAML_BAD_FORMATTING;
return false;
}
FinishEvent(ctx);
return true;
}
bool CheckMappingEvent(ctr_yaml_context *ctx)
{
GetEvent(ctx);
if(!EventIsMappingStart(ctx)){
FinishEvent(ctx);
//fprintf(stderr,"[-] Bad formatting in Spec file (Expected Mapping)\n");
//ctx->error = YAML_BAD_FORMATTING;
return false;
}
FinishEvent(ctx);
return true;
}
void BadYamlFormatting(void)
{
fprintf(stderr,"[-] Bad formatting in Spec file\n");
}
bool cmpYamlValue(char *string,ctr_yaml_context *ctx)
{
return (strcmp(GetYamlString(ctx),string) == 0);
}
bool casecmpYamlValue(char *string,ctr_yaml_context *ctx)
{
return (strcasecmp(GetYamlString(ctx),string) == 0);
}
void SetSimpleYAMLValue(char **dest, char *key, ctr_yaml_context *ctx, u32 size_limit)
{
if(*dest){
fprintf(stderr,"[-] Item '%s' is already set\n",key);
ctx->error = YAML_MEM_ERROR;
return;
}
GetEvent(ctx);
if(ctx->error || ctx->done) return;
if(!EventIsScalar(ctx)){
fprintf(stderr,"[-] '%s' requires a value\n",key);
ctx->error = YAML_BAD_FORMATTING;
return;
}
if(!GetYamlStringSize(ctx)) return;
u32 size = GetYamlStringSize(ctx);
if(size > size_limit && size_limit) size = size_limit;
char *tmp = *dest;
tmp = malloc(size+2);
if(!tmp) {
ctx->error = YAML_MEM_ERROR;
return;
}
memset(tmp,0,size+2);
memcpy(tmp,GetYamlString(ctx),size);
//printf("Setting %s to %s (size of %d)\n",key,GetYamlString(ctx),size);
//printf("Check: %s & %x\n",tmp,tmp);
*dest = tmp;
}
bool SetBoolYAMLValue(char *key, ctr_yaml_context *ctx)
{
GetEvent(ctx);
if(ctx->error || ctx->done) return false;
if(!EventIsScalar(ctx)){
fprintf(stderr,"[-] '%s' requires a value\n",key);
ctx->error = YAML_BAD_FORMATTING;
return false;
}
if(!GetYamlStringSize(ctx)){
fprintf(stderr,"[-] '%s' requires a value\n",key);
ctx->error = YAML_BAD_FORMATTING;
return false;
}
if(casecmpYamlValue("true",ctx)) return true;
if(casecmpYamlValue("false",ctx)) return false;
fprintf(stderr,"[-] Invalid '%s'\n",key);
ctx->error = YAML_BAD_FORMATTING;
return false;
}
u32 SetYAMLSequence(char ***dest, char *key, ctr_yaml_context *ctx)
{
if(*dest){
fprintf(stderr,"[-] %s already set\n",key);
ctx->error = YAML_MEM_ERROR;
return 0;
}
u32 ActualCount = 0;
u32 SlotCount = 0;
char **tmp = *dest;
if(!CheckSequenceEvent(ctx)) return 0;
SlotCount = 10;
tmp = malloc((SlotCount+1)*sizeof(char*));
if(!tmp){
ctx->error = YAML_MEM_ERROR;
return 0;
}
memset(tmp,0,(SlotCount+1)*sizeof(char*));
GetEvent(ctx);
if(ctx->error || ctx->done) return 0;
if(!EventIsScalar(ctx)){
fprintf(stderr,"[-] '%s' requires a value\n",key);
ctx->error = YAML_BAD_FORMATTING;
return 0;
}
if(!GetYamlStringSize(ctx)) return 0;
u32 InitLevel = ctx->Level;
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return 0;
tmp[ActualCount] = malloc(GetYamlStringSize(ctx)+1);
memset(tmp[ActualCount],0,GetYamlStringSize(ctx)+1);
memcpy(tmp[ActualCount],GetYamlString(ctx),GetYamlStringSize(ctx));
ActualCount++;
if(ActualCount >= SlotCount){ // if Exceeding Ptr capacity, expand buffer
SlotCount = SlotCount*2;
char **tmp1 = malloc((SlotCount+1)*sizeof(char*)); // allocate new buffer
if(!tmp1){
ctx->error = YAML_MEM_ERROR;
return 0;
}
memset(tmp1,0,(SlotCount+1)*sizeof(char*));
for(u32 i = 0; i < ActualCount; i++) tmp1[i] = tmp[i]; // Transfer ptrs
free(tmp); // free original buffer
tmp = tmp1; // transfer main ptr
}
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
*dest = tmp; // Give main ptr to location
return ActualCount++; // return number of strings
}
u32 SetYAMLSequenceFromMapping(char ***dest, char *key, ctr_yaml_context *ctx, bool StoreKey)
{
if(*dest){
fprintf(stderr,"[-] %s already set\n",key);
ctx->error = YAML_MEM_ERROR;
return 0;
}
u32 ActualCount = 0;
u32 SlotCount = 0;
char **tmp = *dest;
if(!CheckMappingEvent(ctx)) return 0;
SlotCount = 10;
tmp = malloc((SlotCount+1)*sizeof(char*));
if(!tmp){
ctx->error = YAML_MEM_ERROR;
return 0;
}
memset(tmp,0,(SlotCount+1)*sizeof(char*));
GetEvent(ctx);
if(ctx->error || ctx->done) return 0;
if(!EventIsScalar(ctx)){
fprintf(stderr,"[-] '%s' requires a value\n",key);
ctx->error = YAML_BAD_FORMATTING;
return 0;
}
if(!GetYamlStringSize(ctx)) return 0;
u32 InitLevel = ctx->Level;
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return 0;
if(ctx->IsKey == StoreKey){
tmp[ActualCount] = malloc(GetYamlStringSize(ctx)+1);
memset(tmp[ActualCount],0,GetYamlStringSize(ctx)+1);
memcpy(tmp[ActualCount],GetYamlString(ctx),GetYamlStringSize(ctx));
ActualCount++;
if(ActualCount >= SlotCount){ // if Exceeding Ptr capacity, expand buffer
SlotCount = SlotCount*2;
char **tmp1 = malloc((SlotCount+1)*sizeof(char*)); // allocate new buffer
if(!tmp1){
ctx->error = YAML_MEM_ERROR;
return 0;
}
memset(tmp1,0,(SlotCount+1)*sizeof(char*));
for(u32 i = 0; i < ActualCount; i++) tmp1[i] = tmp[i]; // Transfer ptrs
free(tmp); // free original buffer
tmp = tmp1; // transfer main ptr
}
}
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
*dest = tmp; // Give main ptr to location
return ActualCount++; // return number of strings
}
void SkipYAMLGroup(ctr_yaml_context *ctx) // Why Nintendo? Why is this necessary? Why can't you just create valid .desc files?
{
FinishEvent(ctx);
GetEvent(ctx);
if(!EventIsMappingStart(ctx) && !EventIsSequenceStart(ctx) && EventIsScalar(ctx)) return;
FinishEvent(ctx);
GetEvent(ctx);
if(ctx->error || ctx->done) return;
if(!EventIsScalar(ctx)){
fprintf(stderr,"[-] 'Format error\n");
ctx->error = YAML_BAD_FORMATTING;
return;
}
if(!GetYamlStringSize(ctx)) return;
u32 InitLevel = ctx->Level;
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
yaml_ctr.h
-60
View File
@@ -1,60 +0,0 @@
#ifndef _YAML_H_
#define _YAML_H_
typedef enum
{
YAML_API_ERROR = -1,
YAML_BAD_GROUP_HEADER = -2,
YAML_BAD_FORMATTING = -3,
YAML_MEM_ERROR = -4,
YAML_UNKNOWN_KEY = -5,
} ctr_yaml_error;
typedef struct
{
// For Continued Parsing of file
yaml_parser_t parser;
yaml_event_t event;
bool done;
int error;
// Important Details
bool IsSequence;
bool IsKey;
yaml_event_type_t prev_event;
u32 Level;
} ctr_yaml_context;
#endif
// Public Prototypes
int GetYamlSettings(user_settings *set);
// For scalar events
char *GetYamlString(ctr_yaml_context *ctx);
u32 GetYamlStringSize(ctr_yaml_context *ctx);
bool cmpYamlValue(char *string,ctr_yaml_context *ctx); // Compares a string to the current scalar event
bool casecmpYamlValue(char *string,ctr_yaml_context *ctx); // same as above but ignores case
// Event Handlers
void GetEvent(ctr_yaml_context *ctx);
void FinishEvent(ctr_yaml_context *ctx);
// Event Type Checks
bool EventIsScalar(ctr_yaml_context *ctx);
bool EventIsMappingStart(ctr_yaml_context *ctx);
bool EventIsMappingEnd(ctr_yaml_context *ctx);
bool EventIsSequenceStart(ctr_yaml_context *ctx);
bool EventIsSequenceEnd(ctr_yaml_context *ctx);
bool CheckMappingEvent(ctr_yaml_context *ctx); // With extra implement, use if lazy
bool CheckSequenceEvent(ctr_yaml_context *ctx); // With extra implement, use if lazy
// Functions which store values
void SetSimpleYAMLValue(char **dest, char *key, ctr_yaml_context *ctx, u32 size_limit);
bool SetBoolYAMLValue(char *key, ctr_yaml_context *ctx);
u32 SetYAMLSequence(char ***dest, char *key, ctr_yaml_context *ctx);
u32 SetYAMLSequenceFromMapping(char ***dest, char *key, ctr_yaml_context *ctx, bool StoreKey);
void SkipYAMLGroup(ctr_yaml_context *ctx);
yamlsettings.c
-374
View File
@@ -1,374 +0,0 @@
#include "lib.h"
#include "yamlsettings.h"
void EvaluateRSF(rsf_settings *rsf, ctr_yaml_context *ctx)
{
u32 start_level = ctx->Level-1;
/* Check Group Key for Validity */
CHECK_Group:
//printf("RSF Found: %s\n",GetYamlString(ctx));
if(cmpYamlValue("Option",ctx)) {FinishEvent(ctx); GET_Option(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("AccessControlInfo",ctx)) {FinishEvent(ctx); GET_AccessControlInfo(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("SystemControlInfo",ctx)) {FinishEvent(ctx); GET_SystemControlInfo(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("BasicInfo",ctx)) {FinishEvent(ctx); GET_BasicInfo(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("Rom",ctx)) {FinishEvent(ctx); GET_Rom(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("ExeFs",ctx)) {FinishEvent(ctx); GET_ExeFs(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("PlainRegion",ctx)) {FinishEvent(ctx); GET_PlainRegion(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("TitleInfo",ctx)) {FinishEvent(ctx); GET_TitleInfo(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("CardInfo",ctx)) {FinishEvent(ctx); GET_CardInfo(ctx,rsf); goto GET_NextGroup;}
else if(cmpYamlValue("CommonHeaderKey",ctx)) {FinishEvent(ctx); GET_CommonHeaderKey(ctx,rsf); goto GET_NextGroup;}
// If not recognised escape:
fprintf(stderr,"[-] Unrecognised Key: '%s'\n",GetYamlString(ctx));
FinishEvent(ctx);
ctx->error = YAML_BAD_GROUP_HEADER;
return;
/* Get Next Group and call check */
GET_NextGroup:
// If done return
if(ctx->done || ctx->error) return;
// Recursively getting events until done or has value
if(!ctx->event.type) GetEvent(ctx);
if(ctx->Level <= start_level) return; // No longer in RSF Domain
while(!EventIsScalar(ctx)){
if(ctx->done || ctx->error) return;
if(ctx->Level <= start_level) return; // No longer in RSF Domain
FinishEvent(ctx);
GetEvent(ctx);
}
goto CHECK_Group;
}
void GET_Option(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("AllowUnalignedSection",ctx)) rsf->Option.AllowUnalignedSection = SetBoolYAMLValue("AllowUnalignedSection",ctx);
//else if(cmpYamlValue("NoPadding",ctx)) rsf->Option.NoPadding = SetBoolYAMLValue("NoPadding",ctx);
else if(cmpYamlValue("EnableCrypt",ctx)) rsf->Option.EnableCrypt = SetBoolYAMLValue("EnableCrypt",ctx);
else if(cmpYamlValue("EnableCompress",ctx)) rsf->Option.EnableCompress = SetBoolYAMLValue("EnableCompress",ctx);
else if(cmpYamlValue("FreeProductCode",ctx)) rsf->Option.FreeProductCode = SetBoolYAMLValue("FreeProductCode",ctx);
else if(cmpYamlValue("UseOnSD",ctx)) rsf->Option.UseOnSD = SetBoolYAMLValue("UseOnSD",ctx);
else if(cmpYamlValue("PageSize",ctx)) SetSimpleYAMLValue(&rsf->Option.PageSize,"PageSize",ctx,0);
//else if(cmpYamlValue("AppendSystemCall",ctx)) rsf->Option.AppendSystemCallNum = SetYAMLSequence(&rsf->Option.AppendSystemCall,"AppendSystemCall",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_AccessControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("DisableDebug",ctx)) rsf->AccessControlInfo.DisableDebug = SetBoolYAMLValue("DisableDebug",ctx);
else if(cmpYamlValue("EnableForceDebug",ctx)) rsf->AccessControlInfo.EnableForceDebug = SetBoolYAMLValue("EnableForceDebug",ctx);
else if(cmpYamlValue("CanWriteSharedPage",ctx)) rsf->AccessControlInfo.CanWriteSharedPage = SetBoolYAMLValue("CanWriteSharedPage",ctx);
else if(cmpYamlValue("CanUsePrivilegedPriority",ctx)) rsf->AccessControlInfo.CanUsePrivilegedPriority = SetBoolYAMLValue("CanUsePrivilegedPriority",ctx);
else if(cmpYamlValue("CanUseNonAlphabetAndNumber",ctx)) rsf->AccessControlInfo.CanUseNonAlphabetAndNumber = SetBoolYAMLValue("CanUseNonAlphabetAndNumber",ctx);
else if(cmpYamlValue("PermitMainFunctionArgument",ctx)) rsf->AccessControlInfo.PermitMainFunctionArgument = SetBoolYAMLValue("PermitMainFunctionArgument",ctx);
else if(cmpYamlValue("CanShareDeviceMemory",ctx)) rsf->AccessControlInfo.CanShareDeviceMemory = SetBoolYAMLValue("CanShareDeviceMemory",ctx);
else if(cmpYamlValue("UseOtherVariationSaveData",ctx)) rsf->AccessControlInfo.UseOtherVariationSaveData = SetBoolYAMLValue("UseOtherVariationSaveData",ctx);
else if(cmpYamlValue("UseExtSaveData",ctx)) rsf->AccessControlInfo.UseExtSaveData = SetBoolYAMLValue("UseExtSaveData",ctx);
else if(cmpYamlValue("UseExtendedSaveDataAccessControl",ctx)) rsf->AccessControlInfo.UseExtendedSaveDataAccessControl = SetBoolYAMLValue("UseExtendedSaveDataAccessControl",ctx);
else if(cmpYamlValue("RunnableOnSleep",ctx)) rsf->AccessControlInfo.RunnableOnSleep = SetBoolYAMLValue("RunnableOnSleep",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("IdealProcessor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.IdealProcessor,"IdealProcessor",ctx,0);
else if(cmpYamlValue("Priority",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.Priority,"Priority",ctx,0);
else if(cmpYamlValue("MemoryType",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.MemoryType,"MemoryType",ctx,0);
else if(cmpYamlValue("SystemMode",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.SystemMode,"SystemMode",ctx,0);
else if(cmpYamlValue("CoreVersion",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.CoreVersion,"CoreVersion",ctx,0);
else if(cmpYamlValue("HandleTableSize",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.HandleTableSize,"HandleTableSize",ctx,0);
else if(cmpYamlValue("SystemSaveDataId1",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.SystemSaveDataId1,"SystemSaveDataId1",ctx,0);
else if(cmpYamlValue("SystemSaveDataId2",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.SystemSaveDataId2,"SystemSaveDataId2",ctx,0);
else if(cmpYamlValue("OtherUserSaveDataId1",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.OtherUserSaveDataId1,"OtherUserSaveDataId1",ctx,0);
else if(cmpYamlValue("OtherUserSaveDataId2",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.OtherUserSaveDataId2,"OtherUserSaveDataId2",ctx,0);
else if(cmpYamlValue("OtherUserSaveDataId3",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.OtherUserSaveDataId3,"OtherUserSaveDataId3",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("DescVersion",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.DescVersion,"DescVersion",ctx,0);
//else if(cmpYamlValue("CryptoKey",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.CryptoKey,"CryptoKey",ctx,0);
else if(cmpYamlValue("ResourceLimitCategory",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ResourceLimitCategory,"ResourceLimitCategory",ctx,0);
else if(cmpYamlValue("ReleaseKernelMajor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ReleaseKernelMajor,"ReleaseKernelMajor",ctx,0);
else if(cmpYamlValue("ReleaseKernelMinor",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.ReleaseKernelMinor,"ReleaseKernelMinor",ctx,0);
else if(cmpYamlValue("MaxCpu",ctx)) SetSimpleYAMLValue(&rsf->AccessControlInfo.MaxCpu,"MaxCpu",ctx,0);
else if(cmpYamlValue("MemoryMapping",ctx)) rsf->AccessControlInfo.MemoryMappingNum = SetYAMLSequence(&rsf->AccessControlInfo.MemoryMapping,"MemoryMapping",ctx);
else if(cmpYamlValue("IORegisterMapping",ctx)) rsf->AccessControlInfo.IORegisterMappingNum = SetYAMLSequence(&rsf->AccessControlInfo.IORegisterMapping,"IORegisterMapping",ctx);
else if(cmpYamlValue("FileSystemAccess",ctx)) rsf->AccessControlInfo.FileSystemAccessNum = SetYAMLSequence(&rsf->AccessControlInfo.FileSystemAccess,"FileSystemAccess",ctx);
else if(cmpYamlValue("IoAccessControl",ctx)) rsf->AccessControlInfo.IoAccessControlNum = SetYAMLSequence(&rsf->AccessControlInfo.IoAccessControl,"IoAccessControl",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("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("AccessibleSaveDataIds",ctx)) rsf->AccessControlInfo.AccessibleSaveDataIdsNum = SetYAMLSequence(&rsf->AccessControlInfo.AccessibleSaveDataIds,"AccessibleSaveDataIds",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_SystemControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("AppType",ctx)) SetSimpleYAMLValue(&rsf->SystemControlInfo.AppType,"AppType",ctx,0);
else if(cmpYamlValue("StackSize",ctx)) SetSimpleYAMLValue(&rsf->SystemControlInfo.StackSize,"StackSize",ctx,0);
else if(cmpYamlValue("RemasterVersion",ctx)) SetSimpleYAMLValue(&rsf->SystemControlInfo.RemasterVersion,"RemasterVersion",ctx,0);
else if(cmpYamlValue("JumpId",ctx)) SetSimpleYAMLValue(&rsf->SystemControlInfo.JumpId,"JumpId",ctx,0);
else if(cmpYamlValue("Dependency",ctx)) rsf->SystemControlInfo.DependencyNum = SetYAMLSequenceFromMapping(&rsf->SystemControlInfo.Dependency,"Dependency",ctx,false);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_BasicInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("MediaFootPadding",ctx)) rsf->BasicInfo.MediaFootPadding = SetBoolYAMLValue("MediaFootPadding",ctx);
else if(cmpYamlValue("Title",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.Title,"Title",ctx,0);
else if(cmpYamlValue("CompanyCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.CompanyCode,"CompanyCode",ctx,0);
else if(cmpYamlValue("ProductCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.ProductCode,"ProductCode",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("Logo",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.Logo,"Logo",ctx,0);
//else if(cmpYamlValue("BackupMemoryType",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.BackupMemoryType,"BackupMemoryType",ctx,0);
//else if(cmpYamlValue("InitialCode",ctx)) SetSimpleYAMLValue(&rsf->BasicInfo.InitialCode,"InitialCode",ctx,0);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_Rom(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("HostRoot",ctx)) SetSimpleYAMLValue(&rsf->Rom.HostRoot,"HostRoot",ctx,0);
//else if(cmpYamlValue("Padding",ctx)) SetSimpleYAMLValue(&rsf->Rom.Padding,"Padding",ctx,0);
else if(cmpYamlValue("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("Reject",ctx)) rsf->Rom.RejectNum = SetYAMLSequence(&rsf->Rom.Reject,"Reject",ctx);
else if(cmpYamlValue("Include",ctx)) rsf->Rom.IncludeNum = SetYAMLSequence(&rsf->Rom.Include,"Include",ctx);
else if(cmpYamlValue("File",ctx)) rsf->Rom.FileNum = SetYAMLSequence(&rsf->Rom.File,"File",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_ExeFs(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("Text",ctx)) rsf->ExeFs.TextNum = SetYAMLSequence(&rsf->ExeFs.Text,"Text",ctx);
else if(cmpYamlValue("ReadOnly",ctx)) rsf->ExeFs.ReadOnlyNum = SetYAMLSequence(&rsf->ExeFs.ReadOnly,"ReadOnly",ctx);
else if(cmpYamlValue("ReadWrite",ctx)) rsf->ExeFs.ReadWriteNum = SetYAMLSequence(&rsf->ExeFs.ReadWrite,"ReadWrite",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_PlainRegion(ctr_yaml_context *ctx, rsf_settings *rsf)
{
rsf->PlainRegionNum = SetYAMLSequence(&rsf->PlainRegion,"PlainRegion",ctx);
}
void GET_TitleInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("Category",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Category,"Category",ctx,0);
//else if(cmpYamlValue("Platform",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Platform,"Platform",ctx,0);
else if(cmpYamlValue("UniqueId",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.UniqueId,"UniqueId",ctx,0);
else if(cmpYamlValue("Version",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Version,"Version",ctx,0);
else if(cmpYamlValue("ContentsIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ContentsIndex,"ContentsIndex",ctx,0);
else if(cmpYamlValue("Variation",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Variation,"Variation",ctx,0);
//else if(cmpYamlValue("Use",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.Use,"Use",ctx,0);
else if(cmpYamlValue("ChildIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.ChildIndex,"ChildIndex",ctx,0);
else if(cmpYamlValue("DemoIndex",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.DemoIndex,"DemoIndex",ctx,0);
else if(cmpYamlValue("TargetCategory",ctx)) SetSimpleYAMLValue(&rsf->TitleInfo.TargetCategory,"TargetCategory",ctx,0);
else if(cmpYamlValue("CategoryFlags",ctx)) rsf->TitleInfo.CategoryFlagsNum = SetYAMLSequence(&rsf->TitleInfo.CategoryFlags,"CategoryFlags",ctx);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_CardInfo(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("WritableAddress",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.WritableAddress,"WritableAddress",ctx,0);
else if(cmpYamlValue("CardType",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.CardType,"CardType",ctx,0);
else if(cmpYamlValue("CryptoType",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.CryptoType,"CryptoType",ctx,0);
else if(cmpYamlValue("CardDevice",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.CardDevice,"CardDevice",ctx,0);
else if(cmpYamlValue("MediaType",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.MediaType,"MediaType",ctx,0);
else if(cmpYamlValue("BackupWriteWaitTime",ctx)) SetSimpleYAMLValue(&rsf->CardInfo.BackupWriteWaitTime,"BackupWriteWaitTime",ctx,0);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
void GET_CommonHeaderKey(ctr_yaml_context *ctx, rsf_settings *rsf)
{
/* Checking That Group is in a map */
if(!CheckMappingEvent(ctx)) return;
u32 InitLevel = ctx->Level;
/* Checking each child */
GetEvent(ctx);
rsf->CommonHeaderKey.Found = true;
while(ctx->Level == InitLevel){
if(ctx->error || ctx->done) return;
// Handle childs
if(cmpYamlValue("D",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.D,"D",ctx,0);
else if(cmpYamlValue("P",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.P,"P",ctx,0);
else if(cmpYamlValue("Q",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.Q,"Q",ctx,0);
else if(cmpYamlValue("DP",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.DP,"DP",ctx,0);
else if(cmpYamlValue("DQ",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.DQ,"DQ",ctx,0);
else if(cmpYamlValue("InverseQ",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.InverseQ,"InverseQ",ctx,0);
else if(cmpYamlValue("Modulus",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.Modulus,"Modulus",ctx,0);
else if(cmpYamlValue("Exponent",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.Exponent,"Exponent",ctx,0);
else if(cmpYamlValue("Signature",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.AccCtlDescSign,"Signature",ctx,0);
else if(cmpYamlValue("Descriptor",ctx)) SetSimpleYAMLValue(&rsf->CommonHeaderKey.AccCtlDescBin,"Descriptor",ctx,0);
else{
fprintf(stderr,"[-] Unrecognised key '%s'\n",GetYamlString(ctx));
ctx->error = YAML_UNKNOWN_KEY;
FinishEvent(ctx);
return;
}
// Finish event start next
FinishEvent(ctx);
GetEvent(ctx);
}
FinishEvent(ctx);
}
yamlsettings.h
-14
View File
@@ -1,14 +0,0 @@
int MergeSpecData(rsf_settings *out, rsf_settings *desc, rsf_settings *rsf);
void EvaluateRSF(rsf_settings *rsf, ctr_yaml_context *ctx);
void GET_Option(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_AccessControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_SystemControlInfo(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_BasicInfo(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_Rom(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_ExeFs(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_PlainRegion(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_TitleInfo(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_CardInfo(ctr_yaml_context *ctx, rsf_settings *rsf);
void GET_CommonHeaderKey(ctr_yaml_context *ctx, rsf_settings *rsf);