1
0
Fork 0
mirror of https://github.com/DarkMatterCore/nxdumptool.git synced 2024-10-30 15:31:46 +00:00
nxdumptool/source/core/pfs.c
2022-03-17 13:58:40 +01:00

382 lines
13 KiB
C

/*
* pfs.c
*
* Copyright (c) 2020-2022, DarkMatterCore <pabloacurielz@gmail.com>.
*
* This file is part of nxdumptool (https://github.com/DarkMatterCore/nxdumptool).
*
* nxdumptool 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.
*
* nxdumptool 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 <https://www.gnu.org/licenses/>.
*/
#include "nxdt_utils.h"
#include "pfs.h"
#include "npdm.h"
#define PFS_FULL_HEADER_ALIGNMENT 0x20
bool pfsInitializeContext(PartitionFileSystemContext *out, NcaFsSectionContext *nca_fs_ctx)
{
NcaContext *nca_ctx = NULL;
u32 magic = 0;
PartitionFileSystemHeader pfs_header = {0};
PartitionFileSystemEntry *main_npdm_entry = NULL;
u32 hash_region_count = 0;
NcaRegion *hash_region = NULL;
bool success = false, dump_fs_header = false;
if (!out || !nca_fs_ctx || !nca_fs_ctx->enabled || nca_fs_ctx->section_type != NcaFsSectionType_PartitionFs || nca_fs_ctx->header.fs_type != NcaFsType_PartitionFs || \
nca_fs_ctx->header.hash_type != NcaHashType_HierarchicalSha256 || !(nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx) || (nca_ctx->rights_id_available && !nca_ctx->titlekey_retrieved))
{
LOG_MSG("Invalid parameters!");
return false;
}
/* Free output context beforehand. */
pfsFreeContext(out);
/* Fill context. */
out->nca_fs_ctx = nca_fs_ctx;
if (!ncaValidateHierarchicalSha256Offsets(&(nca_fs_ctx->header.hash_data.hierarchical_sha256_data), nca_fs_ctx->section_size))
{
LOG_MSG("Invalid HierarchicalSha256 block!");
goto end;
}
hash_region_count = nca_fs_ctx->header.hash_data.hierarchical_sha256_data.hash_region_count;
hash_region = &(nca_fs_ctx->header.hash_data.hierarchical_sha256_data.hash_region[hash_region_count - 1]);
out->offset = hash_region->offset;
out->size = hash_region->size;
/* Read partial Partition FS header. */
if (!ncaReadFsSection(nca_fs_ctx, &pfs_header, sizeof(PartitionFileSystemHeader), out->offset))
{
LOG_MSG("Failed to read partial Partition FS header!");
goto end;
}
magic = __builtin_bswap32(pfs_header.magic);
if (magic != PFS0_MAGIC)
{
LOG_MSG("Invalid Partition FS magic word! (0x%08X).", magic);
dump_fs_header = true;
goto end;
}
if (!pfs_header.entry_count || !pfs_header.name_table_size)
{
LOG_MSG("Invalid Partition FS entry count / name table size!");
dump_fs_header = true;
goto end;
}
/* Calculate full Partition FS header size. */
out->header_size = (sizeof(PartitionFileSystemHeader) + (pfs_header.entry_count * sizeof(PartitionFileSystemEntry)) + pfs_header.name_table_size);
/* Allocate memory for the full Partition FS header. */
out->header = calloc(out->header_size, sizeof(u8));
if (!out->header)
{
LOG_MSG("Unable to allocate 0x%lX bytes buffer for the full Partition FS header!", out->header_size);
goto end;
}
/* Read full Partition FS header. */
if (!ncaReadFsSection(nca_fs_ctx, out->header, out->header_size, out->offset))
{
LOG_MSG("Failed to read full Partition FS header!");
goto end;
}
/* Check if we're dealing with an ExeFS section. */
if ((main_npdm_entry = pfsGetEntryByName(out, "main.npdm")) != NULL && pfsReadEntryData(out, main_npdm_entry, &magic, sizeof(u32), 0) && \
__builtin_bswap32(magic) == NPDM_META_MAGIC) out->is_exefs = true;
/* Update flag. */
success = true;
end:
if (!success)
{
if (dump_fs_header) LOG_DATA(&pfs_header, sizeof(PartitionFileSystemHeader), "Partition FS header dump:");
pfsFreeContext(out);
}
return success;
}
bool pfsReadPartitionData(PartitionFileSystemContext *ctx, void *out, u64 read_size, u64 offset)
{
if (!ctx || !ctx->nca_fs_ctx || !ctx->size || !out || !read_size || (offset + read_size) > ctx->size)
{
LOG_MSG("Invalid parameters!");
return false;
}
/* Read partition data. */
if (!ncaReadFsSection(ctx->nca_fs_ctx, out, read_size, ctx->offset + offset))
{
LOG_MSG("Failed to read Partition FS data!");
return false;
}
return true;
}
bool pfsReadEntryData(PartitionFileSystemContext *ctx, PartitionFileSystemEntry *fs_entry, void *out, u64 read_size, u64 offset)
{
if (!ctx || !fs_entry || !fs_entry->size || (fs_entry->offset + fs_entry->size) > ctx->size || !out || !read_size || (offset + read_size) > fs_entry->size)
{
LOG_MSG("Invalid parameters!");
return false;
}
/* Read entry data. */
if (!pfsReadPartitionData(ctx, out, read_size, ctx->header_size + fs_entry->offset + offset))
{
LOG_MSG("Failed to read Partition FS entry data!");
return false;
}
return true;
}
bool pfsGetEntryIndexByName(PartitionFileSystemContext *ctx, const char *name, u32 *out_idx)
{
PartitionFileSystemEntry *fs_entry = NULL;
u32 entry_count = pfsGetEntryCount(ctx), name_table_size = 0;
char *name_table = pfsGetNameTable(ctx);
if (!entry_count || !name_table || !name || !*name || !out_idx)
{
LOG_MSG("Invalid parameters!");
return false;
}
name_table_size = ((PartitionFileSystemHeader*)ctx->header)->name_table_size;
for(u32 i = 0; i < entry_count; i++)
{
if (!(fs_entry = pfsGetEntryByIndex(ctx, i)))
{
LOG_MSG("Failed to retrieve Partition FS entry #%u!", i);
return false;
}
if (fs_entry->name_offset >= name_table_size)
{
LOG_MSG("Name offset from Partition FS entry #%u exceeds name table size!", i);
return false;
}
if (!strcmp(name_table + fs_entry->name_offset, name))
{
*out_idx = i;
return true;
}
}
/* Only log error if we're not dealing with a NPDM. */
if (strcmp(name, "main.npdm") != 0) LOG_MSG("Unable to find Partition FS entry \"%s\"!", name);
return false;
}
bool pfsGetTotalDataSize(PartitionFileSystemContext *ctx, u64 *out_size)
{
u64 total_size = 0;
u32 entry_count = pfsGetEntryCount(ctx);
PartitionFileSystemEntry *fs_entry = NULL;
if (!entry_count || !out_size)
{
LOG_MSG("Invalid parameters!");
return false;
}
for(u32 i = 0; i < entry_count; i++)
{
if (!(fs_entry = pfsGetEntryByIndex(ctx, i)))
{
LOG_MSG("Failed to retrieve Partition FS entry #%u!", i);
return false;
}
total_size += fs_entry->size;
}
*out_size = total_size;
return true;
}
bool pfsGenerateEntryPatch(PartitionFileSystemContext *ctx, PartitionFileSystemEntry *fs_entry, const void *data, u64 data_size, u64 data_offset, NcaHierarchicalSha256Patch *out)
{
if (!ctx || !ctx->nca_fs_ctx || !ctx->header_size || !ctx->header || !fs_entry || !fs_entry->size || (fs_entry->offset + fs_entry->size) > ctx->size || !data || !data_size || \
(data_offset + data_size) > fs_entry->size || !out)
{
LOG_MSG("Invalid parameters!");
return false;
}
u64 partition_offset = (ctx->header_size + fs_entry->offset + data_offset);
if (!ncaGenerateHierarchicalSha256Patch(ctx->nca_fs_ctx, data, data_size, partition_offset, out))
{
LOG_MSG("Failed to generate 0x%lX bytes HierarchicalSha256 patch at offset 0x%lX for Partition FS entry!", data_size, partition_offset);
return false;
}
return true;
}
bool pfsAddEntryInformationToFileContext(PartitionFileSystemFileContext *ctx, const char *entry_name, u64 entry_size, u32 *out_entry_idx)
{
if (!ctx || !entry_name || !*entry_name)
{
LOG_MSG("Invalid parameters!");
return false;
}
PartitionFileSystemHeader *header = &(ctx->header);
PartitionFileSystemEntry *tmp_pfs_entries = NULL, *cur_pfs_entry = NULL, *prev_pfs_entry = NULL;
u64 tmp_pfs_entries_size = ((header->entry_count + 1) * sizeof(PartitionFileSystemEntry));
char *tmp_name_table = NULL;
u32 tmp_name_table_size = (header->name_table_size + strlen(entry_name) + 1);
/* Reallocate Partition FS entries. */
if (!(tmp_pfs_entries = realloc(ctx->entries, tmp_pfs_entries_size)))
{
LOG_MSG("Failed to reallocate Partition FS entries!");
return false;
}
ctx->entries = tmp_pfs_entries;
tmp_pfs_entries = NULL;
/* Update Partition FS entry information. */
cur_pfs_entry = &(ctx->entries[header->entry_count]);
prev_pfs_entry = (header->entry_count ? &(ctx->entries[header->entry_count - 1]) : NULL);
memset(cur_pfs_entry, 0, sizeof(PartitionFileSystemEntry));
cur_pfs_entry->offset = (prev_pfs_entry ? (prev_pfs_entry->offset + prev_pfs_entry->size) : 0);
cur_pfs_entry->size = entry_size;
cur_pfs_entry->name_offset = header->name_table_size;
/* Reallocate Partition FS name table. */
if (!(tmp_name_table = realloc(ctx->name_table, tmp_name_table_size)))
{
LOG_MSG("Failed to reallocate Partition FS name table!");
return false;
}
ctx->name_table = tmp_name_table;
tmp_name_table = NULL;
/* Update Partition FS name table. */
sprintf(ctx->name_table + header->name_table_size, "%s", entry_name);
header->name_table_size = tmp_name_table_size;
/* Update output entry index. */
if (out_entry_idx) *out_entry_idx = header->entry_count;
/* Update Partition FS entry count, name table size and data size. */
header->entry_count++;
ctx->fs_size += entry_size;
return true;
}
bool pfsUpdateEntryNameFromFileContext(PartitionFileSystemFileContext *ctx, u32 entry_idx, const char *new_entry_name)
{
if (!ctx || !ctx->header.entry_count || !ctx->header.name_table_size || !ctx->entries || !ctx->name_table || entry_idx >= ctx->header.entry_count || !new_entry_name || !*new_entry_name)
{
LOG_MSG("Invalid parameters!");
return false;
}
PartitionFileSystemEntry *pfs_entry = &(ctx->entries[entry_idx]);
char *name_table_entry = (ctx->name_table + pfs_entry->name_offset);
size_t new_entry_name_len = strlen(new_entry_name);
size_t cur_entry_name_len = strlen(name_table_entry);
if (new_entry_name_len > cur_entry_name_len)
{
LOG_MSG("New entry name length exceeds previous entry name length! (0x%lX > 0x%lX).", new_entry_name_len, cur_entry_name_len);
return false;
}
memcpy(name_table_entry, new_entry_name, new_entry_name_len);
return true;
}
bool pfsWriteFileContextHeaderToMemoryBuffer(PartitionFileSystemFileContext *ctx, void *buf, u64 buf_size, u64 *out_header_size)
{
if (!ctx || !ctx->header.entry_count || !ctx->header.name_table_size || !ctx->entries || !ctx->name_table || !buf || !out_header_size)
{
LOG_MSG("Invalid parameters!");
return false;
}
PartitionFileSystemHeader *header = &(ctx->header);
u8 *buf_u8 = (u8*)buf;
u64 header_size = 0, full_header_size = 0, block_offset = 0, block_size = 0;
u32 padding_size = 0;
/* Calculate header size. */
header_size = (sizeof(PartitionFileSystemHeader) + (header->entry_count * sizeof(PartitionFileSystemEntry)) + header->name_table_size);
/* Calculate full header size and padding size. */
full_header_size = (IS_ALIGNED(header_size, PFS_FULL_HEADER_ALIGNMENT) ? ALIGN_UP(header_size + 1, PFS_FULL_HEADER_ALIGNMENT) : ALIGN_UP(header_size, PFS_FULL_HEADER_ALIGNMENT));
padding_size = (u32)(full_header_size - header_size);
/* Check buffer size. */
if (buf_size < full_header_size)
{
LOG_MSG("Not enough space available in input buffer to write full Partition FS header! (got 0x%lX, need 0x%lX).", buf_size, full_header_size);
return false;
}
/* Write full header. */
header->name_table_size += padding_size;
block_size = sizeof(PartitionFileSystemHeader);
memcpy(buf_u8 + block_offset, header, block_size);
block_offset += block_size;
header->name_table_size -= padding_size;
block_size = (header->entry_count * sizeof(PartitionFileSystemEntry));
memcpy(buf_u8 + block_offset, ctx->entries, block_size);
block_offset += block_size;
block_size = header->name_table_size;
memcpy(buf_u8 + block_offset, ctx->name_table, block_size);
block_offset += block_size;
memset(buf_u8 + block_offset, 0, padding_size);
/* Update output header size. */
*out_header_size = full_header_size;
return true;
}