Dark98/threeSD
1
0
Fork 0
mirror of https://github.com/Dark98/threeSD.git synced 2026-07-02 16:49:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

ncch: Fix some issues with DecryptToFile

Browse Source 
Now have byte-for-byte accuracy against Godmode9

Now uses a file instead of a path

Preliminary work to support non-executable files
This commit is contained in:
zhupengfei
2020-08-06 20:34:10 +08:00
parent c8f510188c
commit 13409503bf
3 changed files with 80 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/importer.cpp
+8 -1
View File
@@ -479,7 +479,14 @@ bool SDMCImporter::DumpCXI(const ContentSpecifier& specifier, const std::string&
fmt::format("{}{:08x}.app", content_path, tmd.GetBootContentID());
dump_cxi_ncch = std::make_unique<NCCHContainer>(
std::make_shared<SDMCFile>(config.sdmc_path, boot_content_path, "rb"));
return dump_cxi_ncch->DecryptToFile(destination, callback) == ResultStatus::Success;
if (!FileUtil::CreateFullPath(destination)) {
LOG_ERROR(Core, "Failed to create path {}", destination);
return false;
}
return dump_cxi_ncch->DecryptToFile(std::make_shared<FileUtil::IOFile>(destination, "wb"),
callback) == ResultStatus::Success;
}
void SDMCImporter::AbortDumpCXI() {
src/core/ncch/ncch_container.cpp
+70 -49
View File
@@ -427,22 +427,17 @@ ResultStatus NCCHContainer::ReadSeedCrypto(bool& used) {
return ResultStatus::Success;
}
ResultStatus NCCHContainer::DecryptToFile(const std::string& destination,
ResultStatus NCCHContainer::DecryptToFile(std::shared_ptr<FileUtil::IOFile> dest_file,
const ProgressCallback& callback) {
ResultStatus result = Load();
if (result != ResultStatus::Success)
return result;
if (!has_header || !has_exheader)
if (!has_header)
return ResultStatus::ErrorNotUsed;
if (!FileUtil::CreateFullPath(destination)) {
LOG_ERROR(Core, "Could not create path {}", destination);
return ResultStatus::Error;
}
auto dest_file = std::make_shared<FileUtil::IOFile>(destination, "wb");
if (!*dest_file) {
LOG_ERROR(Core, "Could not open file {}", destination);
LOG_ERROR(Core, "File is not open");
return ResultStatus::Error;
}
@@ -457,29 +452,39 @@ ResultStatus NCCHContainer::DecryptToFile(const std::string& destination,
return ret ? ResultStatus::Success : ResultStatus::Error;
}
auto total_size = file->GetSize() - sizeof(NCCH_Header);
// These are written directly instead of using the decryptor
if (has_exheader) {
total_size -= sizeof(ExHeader_Header);
}
if (has_exefs) {
total_size -= sizeof(ExeFs_Header);
}
decryptor.Reset(total_size);
std::size_t written{};
// Write NCCH header
NCCH_Header modified_header = ncch_header;
modified_header.no_crypto.Assign(1);
modified_header.raw_crypto_flags = 0x4; // No crypto
modified_header.secondary_key_slot = 0;
if (dest_file->WriteBytes(&modified_header, sizeof(modified_header)) !=
sizeof(modified_header)) {
LOG_ERROR(Core, "Could not write NCCH header to file {}", destination);
LOG_ERROR(Core, "Could not write NCCH header to file");
return ResultStatus::Error;
}
written += sizeof(NCCH_Header);
// Write Exheader
if (dest_file->WriteBytes(&exheader_header, sizeof(exheader_header)) !=
sizeof(exheader_header)) {
LOG_ERROR(Core, "Could not write Exheader to file {}", destination);
return ResultStatus::Error;
if (has_exheader) {
if (dest_file->WriteBytes(&exheader_header, sizeof(exheader_header)) !=
sizeof(exheader_header)) {
LOG_ERROR(Core, "Could not write Exheader to file");
return ResultStatus::Error;
}
written += sizeof(ExHeader_Header);
}
const auto total_size =
file->GetSize() - sizeof(NCCH_Header) - sizeof(ExHeader_Header) - sizeof(ExeFs_Header);
decryptor.Reset(total_size);
std::size_t written = sizeof(NCCH_Header) + sizeof(ExHeader_Header);
const auto Write = [&](std::string_view name, std::size_t offset, std::size_t size,
bool decrypt = false, const Key::AESKey& key = {},
const Key::AESKey& ctr = {}, std::size_t aes_seek_pos = 0) {
@@ -490,59 +495,75 @@ ResultStatus NCCHContainer::DecryptToFile(const std::string& destination,
if (aborted.exchange(false)) {
return false;
}
file->Seek(written, SEEK_SET);
ASSERT_MSG(written <= offset, "Offsets are not in increasing order");
if (!decryptor.DecryptAndWriteFile(file, offset - written, dest_file, callback)) {
LOG_ERROR(Core, "Could not write data before {} to {}", name, destination);
return false;
// Zero out the gap
const std::array<u8, 1024> zeroes{};
std::size_t zeroes_left = offset - written;
while (zeroes_left > 0) {
const auto to_write = std::min(zeroes.size(), zeroes_left);
if (dest_file->WriteBytes(zeroes.data(), to_write) != to_write) {
LOG_ERROR(Core, "Could not write zeroes before {}", name);
return false;
}
zeroes_left -= to_write;
}
file->Seek(offset, SEEK_SET);
if (aborted.exchange(false)) {
return false;
}
if (!decryptor.DecryptAndWriteFile(file, size, dest_file, callback, decrypt, key, ctr,
aes_seek_pos)) {
LOG_ERROR(Core, "Could not write {} to {}", name, destination);
LOG_ERROR(Core, "Could not write {}", name);
return false;
}
written = offset + size;
return true;
};
if (!Write("logo", ncch_header.logo_region_offset * 0x200,
ncch_header.logo_region_size * 0x200)) {
return ResultStatus::Error;
}
if (!Write("plain region", ncch_header.plain_region_offset * 0x200,
ncch_header.plain_region_size * 0x200)) {
return ResultStatus::Error;
}
// Write ExeFS header
if (dest_file->WriteBytes(&exefs_header, sizeof(exefs_header)) != sizeof(exefs_header)) {
LOG_ERROR(Core, "Could not write ExeFS header to file {}", destination);
return ResultStatus::Error;
}
written += sizeof(ExeFs_Header);
for (unsigned section_number = 0; section_number < kMaxSections; section_number++) {
const auto& section = exefs_header.section[section_number];
if (section.offset == 0 && section.size == 0) { // not used
continue;
}
Key::AESKey key;
if (strcmp(section.name, "icon") == 0 || strcmp(section.name, "banner") == 0) {
key = primary_key;
} else {
key = secondary_key;
}
// Plus 1 for the ExeFS header
if (!Write(section.name, section.offset + (ncch_header.exefs_offset + 1) * 0x200,
section.size, true, key, exefs_ctr, section.offset + sizeof(exefs_header))) {
if (has_exefs) {
if (dest_file->WriteBytes(&exefs_header, sizeof(exefs_header)) != sizeof(exefs_header)) {
LOG_ERROR(Core, "Could not write ExeFS header to file");
return ResultStatus::Error;
}
written += sizeof(ExeFs_Header);
for (unsigned section_number = 0; section_number < kMaxSections; section_number++) {
const auto& section = exefs_header.section[section_number];
if (section.offset == 0 && section.size == 0) { // not used
continue;
}
Key::AESKey key;
if (strcmp(section.name, "icon") == 0 || strcmp(section.name, "banner") == 0) {
key = primary_key;
} else {
key = secondary_key;
}
// Plus 1 for the ExeFS header
if (!Write(section.name, section.offset + (ncch_header.exefs_offset + 1) * 0x200,
section.size, true, key, exefs_ctr, section.offset + sizeof(exefs_header))) {
return ResultStatus::Error;
}
}
}
if (!Write("romfs", ncch_header.romfs_offset * 0x200, ncch_header.romfs_size * 0x200, true,
secondary_key, romfs_ctr)) {
if (has_romfs && !Write("romfs", ncch_header.romfs_offset * 0x200,
ncch_header.romfs_size * 0x200, true, secondary_key, romfs_ctr)) {
return ResultStatus::Error;
}
if (written < file->GetSize()) {
src/core/ncch/ncch_container.h
+2 -1
View File
@@ -56,6 +56,7 @@ struct NCCH_Header {
BitField<1, 1, u8> no_romfs;
BitField<2, 1, u8> no_crypto;
BitField<5, 1, u8> seed_crypto;
u8 raw_crypto_flags;
};
u32_le plain_region_offset;
u32_le plain_region_size;
@@ -271,7 +272,7 @@ public:
* Decrypts this NCCH and write to the destination file.
* @return ResultStatus result of function.
*/
ResultStatus DecryptToFile(const std::string& destination,
ResultStatus DecryptToFile(std::shared_ptr<FileUtil::IOFile> dest_file,
const ProgressCallback& callback = [](std::size_t, std::size_t) {});
/**