1
0
Fork 0
mirror of https://github.com/DarkMatterCore/nxdumptool.git synced 2024-10-30 15:31:46 +00:00
nxdumptool/source/main.c

306 lines
7.7 KiB
C
Raw Normal View History

2020-04-16 01:06:41 +01:00
/*
* Copyright (c) 2020 DarkMatterCore
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope 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/>.
*/
2020-04-11 06:28:26 +01:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <switch.h>
2020-04-15 21:50:07 +01:00
//#include "lvgl_helper.h"
#include "utils.h"
2020-04-11 06:28:26 +01:00
2020-04-22 21:53:20 +01:00
#include <dirent.h>
2020-04-24 10:38:13 +01:00
#include "nca.h"
#include "romfs.h"
2020-04-26 09:35:01 +01:00
#include "rsa.h"
2020-04-24 10:38:13 +01:00
2020-04-11 06:28:26 +01:00
int main(int argc, char *argv[])
{
2020-04-15 21:50:07 +01:00
(void)argc;
(void)argv;
2020-04-11 06:28:26 +01:00
int ret = 0;
2020-04-15 21:50:07 +01:00
LOGFILE("nxdumptool starting.");
if (!utilsInitializeResources())
2020-04-11 06:28:26 +01:00
{
ret = -1;
goto out;
}
2020-04-15 21:50:07 +01:00
/*lv_test();
2020-04-11 06:28:26 +01:00
while(appletMainLoop())
{
2020-04-15 21:50:07 +01:00
lv_task_handler();
if (lvglHelperGetExitFlag()) break;
}*/
consoleInit(NULL);
2020-04-24 10:38:13 +01:00
printf("initializing...\n");
2020-04-15 21:50:07 +01:00
consoleUpdate(NULL);
2020-04-24 10:38:13 +01:00
u8 *buf = NULL;
2020-04-16 01:06:41 +01:00
FILE *tmp_file = NULL;
2020-04-24 10:38:13 +01:00
Ticket tik = {0};
NcaContext *nca_ctx = NULL;
NcmContentStorage ncm_storage = {0};
Result rc = 0;
2020-04-22 21:53:20 +01:00
mkdir("sdmc:/nxdt_test", 0744);
2020-04-24 10:38:13 +01:00
/*FsRightsId rights_id = {
.c = { 0x01, 0x00, 0x82, 0x40, 0x0B, 0xCC, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08 } // Untitled Goose Game
};*/
// Untitled Goose Game
NcmPackagedContentInfo content_info = {
.hash = {
0x8E, 0xF9, 0x20, 0xD4, 0x5E, 0xE1, 0x9E, 0xD1, 0xD2, 0x04, 0xC4, 0xC8, 0x22, 0x50, 0x79, 0xE8,
0x8E, 0xF9, 0x20, 0xD4, 0x5E, 0xE1, 0x9E, 0xD1, 0xD2, 0x04, 0xC4, 0xC8, 0x22, 0x50, 0x79, 0xE8
},
.info = {
.content_id = {
.c = { 0x8E, 0xF9, 0x20, 0xD4, 0x5E, 0xE1, 0x9E, 0xD1, 0xD2, 0x04, 0xC4, 0xC8, 0x22, 0x50, 0x79, 0xE8 }
},
.size = {
0x00, 0x40, 0xAD, 0x31, 0x00, 0x00
},
.content_type = NcmContentType_Program,
.id_offset = 0
}
};
char romfs_path[FS_MAX_PATH] = {0};
u64 romfs_size = 0;
RomFileSystemDirectoryEntry *romfs_dir_entry = NULL;
RomFileSystemFileEntry *romfs_file_entry = NULL;
RomFileSystemContext romfs_ctx = {0};
2020-04-22 21:53:20 +01:00
2020-04-24 10:38:13 +01:00
buf = malloc(0x400000);
if (!buf)
2020-04-16 01:06:41 +01:00
{
2020-04-24 10:38:13 +01:00
printf("read buf failed\n");
goto out2;
2020-04-16 01:06:41 +01:00
}
2020-04-24 10:38:13 +01:00
printf("read buf succeeded\n");
2020-04-16 01:06:41 +01:00
consoleUpdate(NULL);
2020-04-24 10:38:13 +01:00
nca_ctx = calloc(1, sizeof(NcaContext));
if (!nca_ctx)
2020-04-16 01:06:41 +01:00
{
2020-04-24 10:38:13 +01:00
printf("nca ctx buf failed\n");
goto out2;
2020-04-16 01:06:41 +01:00
}
2020-04-24 10:38:13 +01:00
printf("nca ctx buf succeeded\n");
2020-04-16 01:06:41 +01:00
consoleUpdate(NULL);
2020-04-24 10:38:13 +01:00
rc = ncmOpenContentStorage(&ncm_storage, NcmStorageId_SdCard);
if (R_FAILED(rc))
2020-04-16 01:06:41 +01:00
{
2020-04-24 10:38:13 +01:00
printf("ncm open storage failed\n");
goto out2;
2020-04-16 01:06:41 +01:00
}
2020-04-24 10:38:13 +01:00
printf("ncm open storage succeeded\n");
2020-04-16 01:06:41 +01:00
consoleUpdate(NULL);
2020-04-24 10:38:13 +01:00
if (!ncaInitializeContext(nca_ctx, NcmStorageId_SdCard, &ncm_storage, 0, &content_info, &tik))
2020-04-15 21:50:07 +01:00
{
2020-04-24 10:38:13 +01:00
printf("nca initialize ctx failed\n");
goto out2;
2020-04-15 21:50:07 +01:00
}
2020-04-24 10:38:13 +01:00
tmp_file = fopen("sdmc:/nxdt_test/nca_ctx.bin", "wb");
if (tmp_file)
2020-04-15 21:50:07 +01:00
{
2020-04-24 10:38:13 +01:00
fwrite(nca_ctx, 1, sizeof(NcaContext), tmp_file);
fclose(tmp_file);
tmp_file = NULL;
printf("nca ctx saved\n");
2020-04-16 01:06:41 +01:00
} else {
2020-04-24 10:38:13 +01:00
printf("nca ctx not saved\n");
2020-04-11 06:28:26 +01:00
}
2020-04-16 01:06:41 +01:00
consoleUpdate(NULL);
if (!romfsInitializeContext(&romfs_ctx, &(nca_ctx->fs_contexts[1])))
2020-04-24 10:38:13 +01:00
{
printf("romfs initialize ctx failed\n");
2020-04-24 10:38:13 +01:00
goto out2;
2020-04-16 01:06:41 +01:00
}
2020-04-15 21:50:07 +01:00
printf("romfs initialize ctx succeeded\n");
2020-04-15 21:50:07 +01:00
consoleUpdate(NULL);
2020-04-16 01:06:41 +01:00
if (romfsGetTotalDataSize(&romfs_ctx, &romfs_size))
2020-04-16 11:13:11 +01:00
{
printf("romfs size succeeded: 0x%lX\n", romfs_size);
2020-04-16 11:13:11 +01:00
} else {
printf("romfs size failed\n");
2020-04-16 11:13:11 +01:00
}
consoleUpdate(NULL);
tmp_file = fopen("sdmc:/nxdt_test/romfs_ctx.bin", "wb");
2020-04-24 10:38:13 +01:00
if (tmp_file)
{
fwrite(&romfs_ctx, 1, sizeof(RomFileSystemContext), tmp_file);
2020-04-24 10:38:13 +01:00
fclose(tmp_file);
tmp_file = NULL;
printf("romfs ctx saved\n");
2020-04-24 10:38:13 +01:00
} else {
printf("romfs ctx not saved\n");
2020-04-24 10:38:13 +01:00
}
2020-04-24 10:38:13 +01:00
consoleUpdate(NULL);
tmp_file = fopen("sdmc:/nxdt_test/dir_table.bin", "wb");
2020-04-26 09:35:01 +01:00
if (tmp_file)
2020-04-24 10:38:13 +01:00
{
fwrite(romfs_ctx.dir_table, 1, romfs_ctx.dir_table_size, tmp_file);
2020-04-26 09:35:01 +01:00
fclose(tmp_file);
tmp_file = NULL;
printf("dir table saved\n");
2020-04-26 09:35:01 +01:00
} else {
printf("dir table not saved\n");
2020-04-24 10:38:13 +01:00
}
consoleUpdate(NULL);
tmp_file = fopen("sdmc:/nxdt_test/file_table.bin", "wb");
2020-04-24 10:38:13 +01:00
if (tmp_file)
2020-04-20 11:39:41 +01:00
{
fwrite(romfs_ctx.file_table, 1, romfs_ctx.file_table_size, tmp_file);
2020-04-24 10:38:13 +01:00
fclose(tmp_file);
tmp_file = NULL;
printf("file table saved\n");
2020-04-26 09:35:01 +01:00
} else {
printf("file table not saved\n");
2020-04-26 09:35:01 +01:00
}
consoleUpdate(NULL);
romfs_dir_entry = romfsGetDirectoryEntryByOffset(&romfs_ctx, 0x74); // "Resources"
if (!romfs_dir_entry)
{
printf("romfs dir entry failed\n");
goto out2;
}
printf("romfs dir entry success: %s | %p\n", romfs_dir_entry->name, romfs_dir_entry);
consoleUpdate(NULL);
if (romfsGetDirectoryDataSize(&romfs_ctx, romfs_dir_entry, &romfs_size))
{
printf("romfs dir size succeeded: 0x%lX\n", romfs_size);
} else {
printf("romfs dir size failed\n");
}
consoleUpdate(NULL);
romfs_file_entry = romfsGetFileEntryByOffset(&romfs_ctx, romfs_dir_entry->file_offset); // "mscorlib.dll-resources.dat"
if (!romfs_file_entry)
{
printf("romfs file entry failed\n");
goto out2;
}
printf("romfs file entry success: %s | %p\n", romfs_file_entry->name, romfs_file_entry);
consoleUpdate(NULL);
if (!romfsGeneratePathFromDirectoryEntry(&romfs_ctx, romfs_dir_entry, romfs_path, FS_MAX_PATH))
{
printf("romfs generate dir path failed\n");
goto out2;
}
printf("romfs generate dir path success: %s\n", romfs_path);
consoleUpdate(NULL);
romfs_dir_entry = romfsGetDirectoryEntryByPath(&romfs_ctx, romfs_path);
if (!romfs_dir_entry)
{
printf("romfs get dir entry by path failed\n");
goto out2;
}
printf("romfs get dir entry by path success: %s | %p\n", romfs_dir_entry->name, romfs_dir_entry);
consoleUpdate(NULL);
if (!romfsGeneratePathFromFileEntry(&romfs_ctx, romfs_file_entry, romfs_path, FS_MAX_PATH))
{
printf("romfs generate file path failed\n");
goto out2;
}
printf("romfs generate file path success: %s\n", romfs_path);
consoleUpdate(NULL);
romfs_file_entry = romfsGetFileEntryByPath(&romfs_ctx, romfs_path);
if (!romfs_file_entry)
{
printf("romfs get file entry by path failed\n");
goto out2;
}
printf("romfs get file entry by path success: %s | %p\n", romfs_file_entry->name, romfs_file_entry);
consoleUpdate(NULL);
2020-04-26 09:35:01 +01:00
2020-04-20 11:39:41 +01:00
2020-04-26 09:35:01 +01:00
2020-04-26 09:35:01 +01:00
2020-04-24 10:38:13 +01:00
out2:
while(appletMainLoop())
2020-04-20 11:39:41 +01:00
{
2020-04-24 10:38:13 +01:00
consoleUpdate(NULL);
2020-04-20 11:39:41 +01:00
hidScanInput();
if (utilsHidKeysAllDown() & KEY_A) break;
}
2020-04-24 10:38:13 +01:00
if (tmp_file) fclose(tmp_file);
romfsFreeContext(&romfs_ctx);
2020-04-24 10:38:13 +01:00
if (serviceIsActive(&(ncm_storage.s))) ncmContentStorageClose(&ncm_storage);
if (nca_ctx) free(nca_ctx);
if (buf) free(buf);
2020-04-15 21:50:07 +01:00
consoleExit(NULL);
2020-04-11 06:28:26 +01:00
out:
2020-04-15 21:50:07 +01:00
utilsCloseResources();
2020-04-11 06:28:26 +01:00
return ret;
}