Mirrors/hactool
2
0
Fork 0
mirror of https://github.com/SciresM/hactool synced 2024-11-14 00:17:14 +00:00
Code Issues Projects Releases Packages Wiki Activity
hactool/main.c
SciresM 84715a89f8
Merge pull request #35 from jakibaki/master 
getopt_long returns an int, not a char.
2018-07-24 00:36:48 -07:00

688 lines
29 KiB
C
Raw Blame History

#include <getopt.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "types.h"
#include "utils.h"
#include "settings.h"
#include "pki.h"
#include "nca.h"
#include "xci.h"
#include "nax0.h"
#include "extkeys.h"
#include "packages.h"
#include "nso.h"
static char *prog_name = "hactool";
/* Print usage. Taken largely from ctrtool. */
static void usage(void) {
fprintf(stderr,
"hactool (c) SciresM.\n"
"Built: %s %s\n"
"\n"
"Usage: %s [options...] <file>\n"
"Options:\n"
"-i, --info Show file info.\n"
" This is the default action.\n"
"-x, --extract Extract data from file.\n"
" This is also the default action.\n"
" -r, --raw Keep raw data, don't unpack.\n"
" -y, --verify Verify hashes and signatures.\n"
" -d, --dev Decrypt with development keys instead of retail.\n"
" -k, --keyset Load keys from an external file.\n"
" -t, --intype=type Specify input file type [nca, xci, pfs0, romfs, hfs0, npdm, pk11, pk21, ini1, kip1, nax0, keygen]\n"
" --titlekey=key Set title key for Rights ID crypto titles.\n"
" --contentkey=key Set raw key for NCA body decryption.\n"
"NCA options:\n"
" --plaintext=file Specify file path for saving a decrypted copy of the NCA.\n"
" --header=file Specify Header file path.\n"
" --section0=file Specify Section 0 file path.\n"
" --section1=file Specify Section 1 file path.\n"
" --section2=file Specify Section 2 file path.\n"
" --section3=file Specify Section 3 file path.\n"
" --section0dir=dir Specify Section 0 directory path.\n"
" --section1dir=dir Specify Section 1 directory path.\n"
" --section2dir=dir Specify Section 2 directory path.\n"
" --section3dir=dir Specify Section 3 directory path.\n"
" --exefs=file Specify ExeFS file path. Overrides appropriate section file path.\n"
" --exefsdir=dir Specify ExeFS directory path. Overrides appropriate section directory path.\n"
" --romfs=file Specify RomFS file path. Overrides appropriate section file path.\n"
" --romfsdir=dir Specify RomFS directory path. Overrides appropriate section directory path.\n"
" --listromfs List files in RomFS.\n"
" --baseromfs Set Base RomFS to use with update partitions.\n"
" --basenca Set Base NCA to use with update partitions.\n"
" --basefake Use a fake Base RomFS with update partitions (all reads will return 0xCC).\n"
" --onlyupdated Ignore non-updated files in update partitions.\n"
"NPDM options:\n"
" --json=file Specify file path for saving JSON representation of program permissions to.\n"
"KIP1 options:\n"
" --json=file Specify file path for saving JSON representation of program permissions to.\n"
" --uncompressed=f Specify file path for saving uncompressed KIP1.\n"
"NSO0 options:\n"
" --uncompressed=f Specify file path for saving uncompressed NSO0.\n"
"PFS0 options:\n"
" --pfs0dir=dir Specify PFS0 directory path.\n"
" --outdir=dir Specify PFS0 directory path. Overrides previous path, if present.\n"
" --exefsdir=dir Specify PFS0 directory path. Overrides previous paths, if present for ExeFS PFS0.\n"
"RomFS options:\n"
" --romfsdir=dir Specify RomFS directory path.\n"
" --outdir=dir Specify RomFS directory path. Overrides previous path, if present.\n"
" --listromfs List files in RomFS.\n"
"HFS0 options:\n"
" --hfs0dir=dir Specify HFS0 directory path.\n"
" --outdir=dir Specify HFS0 directory path. Overrides previous path, if present.\n"
" --exefsdir=dir Specify HFS0 directory path. Overrides previous paths, if present.\n"
"XCI options:\n"
" --rootdir=dir Specify XCI root HFS0 directory path.\n"
" --updatedir=dir Specify XCI update HFS0 directory path.\n"
" --normaldir=dir Specify XCI normal HFS0 directory path.\n"
" --securedir=dir Specify XCI secure HFS0 directory path.\n"
" --logodir=dir Specify XCI logo HFS0 directory path.\n"
" --outdir=dir Specify XCI directory path. Overrides previous paths, if present.\n"
"Package1 options:\n"
" --package1dir=dir Specify Package1 directory path.\n"
" --outdir=dir Specify Package1 directory path. Overrides previous path, if present.\n"
"Package2 options:\n"
" --package2dir=dir Specify Package2 directory path.\n"
" --outdir=dir Specify Package2 directory path. Overrides previous path, if present.\n"
" --extractini1 Enable INI1 extraction to default directory (redundant with --ini1dir set).\n"
" --ini1dir=dir Specify INI1 directory path. Overrides default path, if present.\n"
"INI1 options:\n"
" --ini1dir=dir Specify INI1 directory path.\n"
" --outdir=dir Specify INI1 directory path. Overrides previous path, if present.\n"
" --saveini1json Enable generation of JSON descriptors for all INI1 members.\n"
"NAX0 options:\n"
" --sdseed=seed Set console unique seed for SD card NAX0 encryption.\n"
" --sdpath=path Set relative path for NAX0 key derivation (ex: /registered/000000FF/cafebabecafebabecafebabecafebabe.nca).\n"
"Key Derivation options:\n"
" --sbk=key Set console unique Secure Boot Key for key derivation.\n"
" --tseckey=key Set console unique TSEC Key for key derivation.\n"
"\n", __TIME__, __DATE__, prog_name);
exit(EXIT_FAILURE);
}
int main(int argc, char **argv) {
hactool_ctx_t tool_ctx;
hactool_ctx_t base_ctx; /* Context for base NCA, if used. */
nca_ctx_t nca_ctx;
char input_name[0x200];
filepath_t keypath;
prog_name = (argc < 1) ? "hactool" : argv[0];
nca_init(&nca_ctx);
memset(&tool_ctx, 0, sizeof(tool_ctx));
memset(&base_ctx, 0, sizeof(base_ctx));
memset(input_name, 0, sizeof(input_name));
filepath_init(&keypath);
nca_ctx.tool_ctx = &tool_ctx;
nca_ctx.is_cli_target = true;
nca_ctx.tool_ctx->file_type = FILETYPE_NCA;
base_ctx.file_type = FILETYPE_NCA;
nca_ctx.tool_ctx->action = ACTION_INFO | ACTION_EXTRACT;
pki_initialize_keyset(&tool_ctx.settings.keyset, KEYSET_RETAIL);
while (1) {
int option_index;
int c;
static struct option long_options[] =
{
{"extract", 0, NULL, 'x'},
{"info", 0, NULL, 'i'},
{"dev", 0, NULL, 'd'},
{"verify", 0, NULL, 'y'},
{"raw", 0, NULL, 'r'},
{"intype", 1, NULL, 't'},
{"keyset", 1, NULL, 'k'},
{"section0", 1, NULL, 0},
{"section1", 1, NULL, 1},
{"section2", 1, NULL, 2},
{"section3", 1, NULL, 3},
{"section0dir", 1, NULL, 4},
{"section1dir", 1, NULL, 5},
{"section2dir", 1, NULL, 6},
{"section3dir", 1, NULL, 7},
{"exefs", 1, NULL, 8},
{"romfs", 1, NULL, 9},
{"exefsdir", 1, NULL, 10},
{"romfsdir", 1, NULL, 11},
{"titlekey", 1, NULL, 12},
{"contentkey", 1, NULL, 13},
{"listromfs", 0, NULL, 14},
{"baseromfs", 1, NULL, 15},
{"basenca", 1, NULL, 16},
{"outdir", 1, NULL, 17},
{"plaintext", 1, NULL, 18},
{"header", 1, NULL, 19},
{"pfs0dir", 1, NULL, 20},
{"hfs0dir", 1, NULL, 21},
{"rootdir", 1, NULL, 22},
{"updatedir", 1, NULL, 23},
{"normaldir", 1, NULL, 24},
{"securedir", 1, NULL, 25},
{"logodir", 1, NULL, 26},
{"package1dir", 1, NULL, 27},
{"package2dir", 1, NULL, 28},
{"ini1dir", 1, NULL, 29},
{"extractini1", 0, NULL, 30},
{"basefake", 0, NULL, 31},
{"onlyupdated", 0, NULL, 32},
{"sdseed", 1, NULL, 33},
{"sdpath", 1, NULL, 34},
{"sbk", 1, NULL, 35},
{"tseckey", 1, NULL, 36},
{"json", 1, NULL, 37},
{"saveini1json", 0, NULL, 38},
{"uncompressed", 1, NULL, 39},
{NULL, 0, NULL, 0},
};
c = getopt_long(argc, argv, "dryxt:ik:", long_options, &option_index);
if (c == -1)
break;
switch (c)
{
case 'i':
nca_ctx.tool_ctx->action |= ACTION_INFO;
break;
case 'x':
nca_ctx.tool_ctx->action |= ACTION_EXTRACT;
break;
case 'y':
nca_ctx.tool_ctx->action |= ACTION_VERIFY;
break;
case 'r':
nca_ctx.tool_ctx->action |= ACTION_RAW;
break;
case 'd':
pki_initialize_keyset(&tool_ctx.settings.keyset, KEYSET_DEV);
nca_ctx.tool_ctx->action |= ACTION_DEV;
break;
case 'k':
filepath_set(&keypath, optarg);
break;
case 't':
if (!strcmp(optarg, "nca")) {
nca_ctx.tool_ctx->file_type = FILETYPE_NCA;
} else if (!strcmp(optarg, "pfs0") || !strcmp(optarg, "exefs")) {
nca_ctx.tool_ctx->file_type = FILETYPE_PFS0;
} else if (!strcmp(optarg, "romfs")) {
nca_ctx.tool_ctx->file_type = FILETYPE_ROMFS;
} else if (!strcmp(optarg, "nca0_romfs") || !strcmp(optarg, "nca0romfs") || !strcmp(optarg, "betaromfs") || !strcmp(optarg, "beta_romfs")) {
nca_ctx.tool_ctx->file_type = FILETYPE_NCA0_ROMFS;
} else if (!strcmp(optarg, "hfs0")) {
nca_ctx.tool_ctx->file_type = FILETYPE_HFS0;
} else if (!strcmp(optarg, "xci") || !strcmp(optarg, "gamecard") || !strcmp(optarg, "gc")) {
nca_ctx.tool_ctx->file_type = FILETYPE_XCI;
} else if (!strcmp(optarg, "npdm") || !strcmp(optarg, "meta")) {
nca_ctx.tool_ctx->file_type = FILETYPE_NPDM;
} else if (!strcmp(optarg, "package1") || !strcmp(optarg, "pk11")) {
nca_ctx.tool_ctx->file_type = FILETYPE_PACKAGE1;
} else if (!strcmp(optarg, "package2") || !strcmp(optarg, "pk21")) {
nca_ctx.tool_ctx->file_type = FILETYPE_PACKAGE2;
} else if (!strcmp(optarg, "ini1")) {
nca_ctx.tool_ctx->file_type = FILETYPE_INI1;
} else if (!strcmp(optarg, "kip1") || !strcmp(optarg, "kip")) {
nca_ctx.tool_ctx->file_type = FILETYPE_KIP1;
} else if (!strcmp(optarg, "nso0") || !strcmp(optarg, "nso")) {
nca_ctx.tool_ctx->file_type = FILETYPE_NSO0;
} else if (!strcmp(optarg, "nax0") || !strcmp(optarg, "nax")) {
nca_ctx.tool_ctx->file_type = FILETYPE_NAX0;
} else if (!strcmp(optarg, "keygen") || !strcmp(optarg, "keys") || !strcmp(optarg, "boot0") || !strcmp(optarg, "boot")) {
nca_ctx.tool_ctx->file_type = FILETYPE_BOOT0;
}
break;
case 0: filepath_set(&nca_ctx.tool_ctx->settings.section_paths[0], optarg); break;
case 1: filepath_set(&nca_ctx.tool_ctx->settings.section_paths[1], optarg); break;
case 2: filepath_set(&nca_ctx.tool_ctx->settings.section_paths[2], optarg); break;
case 3: filepath_set(&nca_ctx.tool_ctx->settings.section_paths[3], optarg); break;
case 4: filepath_set(&nca_ctx.tool_ctx->settings.section_dir_paths[0], optarg); break;
case 5: filepath_set(&nca_ctx.tool_ctx->settings.section_dir_paths[1], optarg); break;
case 6: filepath_set(&nca_ctx.tool_ctx->settings.section_dir_paths[2], optarg); break;
case 7: filepath_set(&nca_ctx.tool_ctx->settings.section_dir_paths[3], optarg); break;
case 8:
nca_ctx.tool_ctx->settings.exefs_path.enabled = 1;
filepath_set(&nca_ctx.tool_ctx->settings.exefs_path.path, optarg);
break;
case 9:
nca_ctx.tool_ctx->settings.romfs_path.enabled = 1;
filepath_set(&nca_ctx.tool_ctx->settings.romfs_path.path, optarg);
break;
case 10:
nca_ctx.tool_ctx->settings.exefs_dir_path.enabled = 1;
filepath_set(&nca_ctx.tool_ctx->settings.exefs_dir_path.path, optarg);
break;
case 11:
nca_ctx.tool_ctx->settings.romfs_dir_path.enabled = 1;
filepath_set(&nca_ctx.tool_ctx->settings.romfs_dir_path.path, optarg);
break;
case 12:
parse_hex_key(nca_ctx.tool_ctx->settings.cli_titlekey, optarg, 16);
nca_ctx.tool_ctx->settings.has_cli_titlekey = 1;
break;
case 13:
parse_hex_key(nca_ctx.tool_ctx->settings.cli_contentkey, optarg, 16);
nca_ctx.tool_ctx->settings.has_cli_contentkey = 1;
break;
case 14:
nca_ctx.tool_ctx->action |= ACTION_LISTROMFS;
break;
case 15:
if (nca_ctx.tool_ctx->base_file != NULL) {
usage();
return EXIT_FAILURE;
}
if ((nca_ctx.tool_ctx->base_file = fopen(optarg, "rb")) == NULL) {
fprintf(stderr, "unable to open %s: %s\n", optarg, strerror(errno));
return EXIT_FAILURE;
}
nca_ctx.tool_ctx->base_file_type = BASEFILE_ROMFS;
break;
case 16:
if (nca_ctx.tool_ctx->base_file != NULL) {
usage();
return EXIT_FAILURE;
}
if ((nca_ctx.tool_ctx->base_file = fopen(optarg, "rb")) == NULL) {
fprintf(stderr, "unable to open %s: %s\n", optarg, strerror(errno));
return EXIT_FAILURE;
}
nca_ctx.tool_ctx->base_file_type = BASEFILE_NCA;
nca_ctx.tool_ctx->base_nca_ctx = malloc(sizeof(*nca_ctx.tool_ctx->base_nca_ctx));
if (nca_ctx.tool_ctx->base_nca_ctx == NULL) {
fprintf(stderr, "Failed to allocate base NCA context!\n");
return EXIT_FAILURE;
}
nca_init(nca_ctx.tool_ctx->base_nca_ctx);
base_ctx.file = nca_ctx.tool_ctx->base_file;
nca_ctx.tool_ctx->base_nca_ctx->file = base_ctx.file;
nca_ctx.tool_ctx->base_nca_ctx->is_cli_target = false;
break;
case 17:
tool_ctx.settings.out_dir_path.enabled = 1;
filepath_set(&tool_ctx.settings.out_dir_path.path, optarg);
break;
case 18:
filepath_set(&nca_ctx.tool_ctx->settings.plaintext_path, optarg);
break;
case 19:
filepath_set(&nca_ctx.tool_ctx->settings.header_path, optarg);
break;
case 20:
filepath_set(&tool_ctx.settings.pfs0_dir_path, optarg);
break;
case 21:
filepath_set(&tool_ctx.settings.hfs0_dir_path, optarg);
break;
case 22:
filepath_set(&tool_ctx.settings.rootpt_dir_path, optarg);
break;
case 23:
filepath_set(&tool_ctx.settings.update_dir_path, optarg);
break;
case 24:
filepath_set(&tool_ctx.settings.normal_dir_path, optarg);
break;
case 25:
filepath_set(&tool_ctx.settings.secure_dir_path, optarg);
break;
case 26:
filepath_set(&tool_ctx.settings.logo_dir_path, optarg);
break;
case 27:
filepath_set(&tool_ctx.settings.pk11_dir_path, optarg);
break;
case 28:
filepath_set(&tool_ctx.settings.pk21_dir_path, optarg);
break;
case 29:
filepath_set(&tool_ctx.settings.ini1_dir_path, optarg);
break;
case 30:
tool_ctx.action |= ACTION_EXTRACTINI1;
break;
case 31:
if (nca_ctx.tool_ctx->base_file != NULL) {
usage();
return EXIT_FAILURE;
}
nca_ctx.tool_ctx->base_file_type = BASEFILE_FAKE;
nca_ctx.tool_ctx->base_file++; /* Guarantees base_file != NULL. I'm so sorry. */
break;
case 32:
tool_ctx.action |= ACTION_ONLYUPDATEDROMFS;
break;
case 33:
parse_hex_key(nca_ctx.tool_ctx->settings.sdseed, optarg, 16);
nca_ctx.tool_ctx->settings.has_sdseed = 1;
for (unsigned int key = 0; key < 2; key++) {
for (unsigned int i = 0; i < 0x20; i++) {
tool_ctx.settings.keyset.sd_card_key_sources[key][i] ^= tool_ctx.settings.sdseed[i & 0xF];
}
}
pki_derive_keys(&tool_ctx.settings.keyset);
break;
case 34:
filepath_set(&tool_ctx.settings.nax0_sd_path, optarg);
break;
case 35:
parse_hex_key(nca_ctx.tool_ctx->settings.keygen_sbk, optarg, 16);
break;
case 36:
parse_hex_key(nca_ctx.tool_ctx->settings.keygen_tsec, optarg, 16);
break;
case 37:
filepath_set(&tool_ctx.settings.npdm_json_path, optarg);
break;
case 38:
tool_ctx.action |= ACTION_SAVEINIJSON;
break;
case 39:
filepath_set(&nca_ctx.tool_ctx->settings.uncompressed_path, optarg);
break;
default:
usage();
return EXIT_FAILURE;
}
}
/* Try to populate default keyfile. */
FILE *keyfile = NULL;
if (keypath.valid == VALIDITY_VALID) {
keyfile = os_fopen(keypath.os_path, OS_MODE_READ);
}
FILE *homekeyfile = open_key_file((tool_ctx.action & ACTION_DEV) ? "dev" : "prod");
if (homekeyfile == NULL) {
printf("[WARN] %s.keys does not exist.\n", (tool_ctx.action & ACTION_DEV) ? "dev" : "prod");
} else if (keyfile == NULL) {
keyfile = homekeyfile;
} else {
fclose(homekeyfile);
}
if (keyfile != NULL) {
extkeys_initialize_keyset(&tool_ctx.settings.keyset, keyfile);
if (tool_ctx.settings.has_sdseed) {
for (unsigned int key = 0; key < 2; key++) {
for (unsigned int i = 0; i < 0x20; i++) {
tool_ctx.settings.keyset.sd_card_key_sources[key][i] ^= tool_ctx.settings.sdseed[i & 0xF];
}
}
}
pki_derive_keys(&tool_ctx.settings.keyset);
fclose(keyfile);
}
/* Try to load titlekeys. */
FILE *titlekeyfile = open_key_file("title");
if (titlekeyfile != NULL) {
extkeys_parse_titlekeys(&tool_ctx.settings, titlekeyfile);
}
if (optind == argc - 1) {
/* Copy input file. */
strncpy(input_name, argv[optind], sizeof(input_name));
} else if (tool_ctx.file_type != FILETYPE_BOOT0 && ((optind < argc) || (argc == 1))) {
usage();
}
/* Special case NAX0. */
if (tool_ctx.file_type == FILETYPE_NAX0) {
nax0_ctx_t nax_ctx;
memset(&nax_ctx, 0, sizeof(nax_ctx));
filepath_set(&nax_ctx.base_path, input_name);
nax_ctx.tool_ctx = &tool_ctx;
nax0_process(&nax_ctx);
if (nax_ctx.aes_ctx) {
free_aes_ctx(nax_ctx.aes_ctx);
}
if (nax_ctx.num_files) {
for (unsigned int i = 0; i < nax_ctx.num_files; i++) {
fclose(nax_ctx.files[i]);
}
}
if (nax_ctx.files) {
free(nax_ctx.files);
}
printf("Done!\n");
return EXIT_SUCCESS;
}
if ((tool_ctx.file = fopen(input_name, "rb")) == NULL && tool_ctx.file_type != FILETYPE_BOOT0) {
fprintf(stderr, "unable to open %s: %s\n", input_name, strerror(errno));
return EXIT_FAILURE;
}
switch (tool_ctx.file_type) {
case FILETYPE_NCA: {
if (nca_ctx.tool_ctx->base_nca_ctx != NULL) {
memcpy(&base_ctx.settings.keyset, &tool_ctx.settings.keyset, sizeof(nca_keyset_t));
nca_ctx.tool_ctx->base_nca_ctx->tool_ctx = &base_ctx;
nca_process(nca_ctx.tool_ctx->base_nca_ctx);
int found_romfs = 0;
for (unsigned int i = 0; i < 4; i++) {
if (nca_ctx.tool_ctx->base_nca_ctx->section_contexts[i].is_present && nca_ctx.tool_ctx->base_nca_ctx->section_contexts[i].type == ROMFS) {
found_romfs = 1;
break;
}
}
if (found_romfs == 0) {
fprintf(stderr, "Unable to locate RomFS in base NCA!\n");
return EXIT_FAILURE;
}
}
nca_ctx.file = tool_ctx.file;
nca_process(&nca_ctx);
nca_free_section_contexts(&nca_ctx);
if (nca_ctx.tool_ctx->base_file_type == BASEFILE_FAKE) {
nca_ctx.tool_ctx->base_file = NULL;
}
if (nca_ctx.tool_ctx->base_file != NULL) {
fclose(nca_ctx.tool_ctx->base_file);
if (nca_ctx.tool_ctx->base_file_type == BASEFILE_NCA) {
nca_free_section_contexts(nca_ctx.tool_ctx->base_nca_ctx);
free(nca_ctx.tool_ctx->base_nca_ctx);
}
}
break;
}
case FILETYPE_PFS0: {
pfs0_ctx_t pfs0_ctx;
memset(&pfs0_ctx, 0, sizeof(pfs0_ctx));
pfs0_ctx.file = tool_ctx.file;
pfs0_ctx.tool_ctx = &tool_ctx;
pfs0_process(&pfs0_ctx);
if (pfs0_ctx.header) {
free(pfs0_ctx.header);
}
if (pfs0_ctx.npdm) {
free(pfs0_ctx.npdm);
}
break;
}
case FILETYPE_ROMFS: {
romfs_ctx_t romfs_ctx;
memset(&romfs_ctx, 0, sizeof(romfs_ctx));
romfs_ctx.file = tool_ctx.file;
romfs_ctx.tool_ctx = &tool_ctx;
romfs_process(&romfs_ctx);
if (romfs_ctx.files) {
free(romfs_ctx.files);
}
if (romfs_ctx.directories) {
free(romfs_ctx.directories);
}
break;
}
case FILETYPE_NCA0_ROMFS: {
nca0_romfs_ctx_t romfs_ctx;
memset(&romfs_ctx, 0, sizeof(romfs_ctx));
romfs_ctx.file = tool_ctx.file;
romfs_ctx.tool_ctx = &tool_ctx;
nca0_romfs_process(&romfs_ctx);
if (romfs_ctx.files) {
free(romfs_ctx.files);
}
if (romfs_ctx.directories) {
free(romfs_ctx.directories);
}
break;
}
case FILETYPE_NPDM: {
npdm_t raw_hdr;
memset(&raw_hdr, 0, sizeof(raw_hdr));
if (fread(&raw_hdr, 1, sizeof(raw_hdr), tool_ctx.file) != sizeof(raw_hdr)) {
fprintf(stderr, "Failed to read NPDM header!\n");
exit(EXIT_FAILURE);
}
if (raw_hdr.magic != MAGIC_META) {
fprintf(stderr, "NPDM seems corrupt!\n");
exit(EXIT_FAILURE);
}
uint64_t npdm_size = raw_hdr.aci0_size + raw_hdr.aci0_offset;
if (raw_hdr.acid_offset + raw_hdr.acid_size > npdm_size) {
npdm_size = raw_hdr.acid_offset + raw_hdr.acid_size;
}
fseeko64(tool_ctx.file, 0, SEEK_SET);
npdm_t *npdm = malloc(npdm_size);
if (npdm == NULL) {
fprintf(stderr, "Failed to allocate NPDM!\n");
exit(EXIT_FAILURE);
}
if (fread(npdm, 1, npdm_size, tool_ctx.file) != npdm_size) {
fprintf(stderr, "Failed to read NPDM!\n");
exit(EXIT_FAILURE);
}
npdm_process(npdm, &tool_ctx);
break;
}
case FILETYPE_HFS0: {
hfs0_ctx_t hfs0_ctx;
memset(&hfs0_ctx, 0, sizeof(hfs0_ctx));
hfs0_ctx.file = tool_ctx.file;
hfs0_ctx.tool_ctx = &tool_ctx;
hfs0_process(&hfs0_ctx);
if (hfs0_ctx.header) {
free(hfs0_ctx.header);
}
break;
}
case FILETYPE_PACKAGE1: {
pk11_ctx_t pk11_ctx;
memset(&pk11_ctx, 0, sizeof(pk11_ctx));
pk11_ctx.file = tool_ctx.file;
pk11_ctx.tool_ctx = &tool_ctx;
pk11_process(&pk11_ctx);
if (pk11_ctx.pk11) {
free(pk11_ctx.pk11);
}
break;
}
case FILETYPE_PACKAGE2: {
pk21_ctx_t pk21_ctx;
memset(&pk21_ctx, 0, sizeof(pk21_ctx));
pk21_ctx.file = tool_ctx.file;
pk21_ctx.tool_ctx = &tool_ctx;
pk21_process(&pk21_ctx);
if (pk21_ctx.sections) {
free(pk21_ctx.sections);
}
break;
}
case FILETYPE_INI1: {
ini1_ctx_t ini1_ctx;
memset(&ini1_ctx, 0, sizeof(ini1_ctx));
ini1_ctx.file = tool_ctx.file;
ini1_ctx.tool_ctx = &tool_ctx;
ini1_process(&ini1_ctx);
if (ini1_ctx.header) {
free(ini1_ctx.header);
}
break;
}
case FILETYPE_KIP1: {
kip1_ctx_t kip1_ctx;
memset(&kip1_ctx, 0, sizeof(kip1_ctx));
kip1_ctx.file = tool_ctx.file;
kip1_ctx.tool_ctx = &tool_ctx;
kip1_process(&kip1_ctx);
if (kip1_ctx.header) {
free(kip1_ctx.header);
}
break;
}
case FILETYPE_NSO0: {
nso0_ctx_t nso0_ctx;
memset(&nso0_ctx, 0, sizeof(nso0_ctx));
nso0_ctx.file = tool_ctx.file;
nso0_ctx.tool_ctx = &tool_ctx;
nso0_process(&nso0_ctx);
if (nso0_ctx.header) {
free(nso0_ctx.header);
}
if (nso0_ctx.uncompressed_header) {
free(nso0_ctx.uncompressed_header);
}
break;
}
case FILETYPE_XCI: {
xci_ctx_t xci_ctx;
memset(&xci_ctx, 0, sizeof(xci_ctx));
xci_ctx.file = tool_ctx.file;
xci_ctx.tool_ctx = &tool_ctx;
xci_process(&xci_ctx);
break;
}
case FILETYPE_BOOT0: {
nca_keyset_t new_keyset;
memcpy(&new_keyset, &tool_ctx.settings.keyset, sizeof(new_keyset));
for (unsigned int i = 0; i < 0x10; i++) {
if (tool_ctx.settings.keygen_sbk[i] != 0) {
memcpy(new_keyset.secure_boot_key, tool_ctx.settings.keygen_sbk, 0x10);
}
}
for (unsigned int i = 0; i < 0x10; i++) {
if (tool_ctx.settings.keygen_tsec[i] != 0) {
memcpy(new_keyset.tsec_key, tool_ctx.settings.keygen_tsec, 0x10);
}
}
for (unsigned int i = 0; tool_ctx.file != NULL && i < 0x20; i++) {
fseek(tool_ctx.file, 0x180000 + 0x200 * i, SEEK_SET);
if (fread(&new_keyset.encrypted_keyblobs[i], sizeof(new_keyset.encrypted_keyblobs[i]), 1, tool_ctx.file) != 1) {
fprintf(stderr, "Error: Failed to read encrypted_keyblob_%02x from boot0!\n", i);
return EXIT_FAILURE;
}
}
printf("Deriving keys...\n");
pki_derive_keys(&new_keyset);
printf("--\n");
printf("All derivable keys (using loaded sources):\n\n");
pki_print_keys(&new_keyset);
break;
}
default: {
fprintf(stderr, "Unknown File Type!\n\n");
usage();
}
}
if (tool_ctx.settings.known_titlekeys.titlekeys != NULL) {
free(tool_ctx.settings.known_titlekeys.titlekeys);
}
if (tool_ctx.file != NULL) {
fclose(tool_ctx.file);
}
printf("Done!\n");
return EXIT_SUCCESS;
}
Reference in a new issue View git blame Copy permalink