summaryrefslogtreecommitdiffstats
path: root/src/core/file_sys
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/file_sys')
-rw-r--r--src/core/file_sys/bis_factory.cpp11
-rw-r--r--src/core/file_sys/card_image.cpp12
-rw-r--r--src/core/file_sys/card_image.h2
-rw-r--r--src/core/file_sys/content_archive.cpp10
-rw-r--r--src/core/file_sys/content_archive.h3
-rw-r--r--src/core/file_sys/registered_cache.cpp14
-rw-r--r--src/core/file_sys/registered_cache.h4
-rw-r--r--src/core/file_sys/sdmc_factory.cpp15
-rw-r--r--src/core/file_sys/sdmc_factory.h7
-rw-r--r--src/core/file_sys/vfs.cpp7
-rw-r--r--src/core/file_sys/vfs.h4
-rw-r--r--src/core/file_sys/xts_archive.cpp169
-rw-r--r--src/core/file_sys/xts_archive.h69
13 files changed, 316 insertions, 11 deletions
diff --git a/src/core/file_sys/bis_factory.cpp b/src/core/file_sys/bis_factory.cpp
index ae4e33800..08a7cea5a 100644
--- a/src/core/file_sys/bis_factory.cpp
+++ b/src/core/file_sys/bis_factory.cpp
@@ -6,19 +6,12 @@
namespace FileSys {
-static VirtualDir GetOrCreateDirectory(const VirtualDir& dir, std::string_view path) {
- const auto res = dir->GetDirectoryRelative(path);
- if (res == nullptr)
- return dir->CreateDirectoryRelative(path);
- return res;
-}
-
BISFactory::BISFactory(VirtualDir nand_root_)
: nand_root(std::move(nand_root_)),
sysnand_cache(std::make_shared<RegisteredCache>(
- GetOrCreateDirectory(nand_root, "/system/Contents/registered"))),
+ GetOrCreateDirectoryRelative(nand_root, "/system/Contents/registered"))),
usrnand_cache(std::make_shared<RegisteredCache>(
- GetOrCreateDirectory(nand_root, "/user/Contents/registered"))) {}
+ GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
return sysnand_cache;
diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index 1d7c7fb10..d61a2ebe1 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -43,6 +43,8 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
partitions[static_cast<size_t>(partition)] = std::make_shared<PartitionFilesystem>(raw);
}
+ program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
+
auto result = AddNCAFromPartition(XCIPartition::Secure);
if (result != Loader::ResultStatus::Success) {
status = result;
@@ -76,6 +78,10 @@ Loader::ResultStatus XCI::GetStatus() const {
return status;
}
+Loader::ResultStatus XCI::GetProgramNCAStatus() const {
+ return program_nca_status;
+}
+
VirtualDir XCI::GetPartition(XCIPartition partition) const {
return partitions[static_cast<size_t>(partition)];
}
@@ -143,6 +149,12 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
if (file->GetExtension() != "nca")
continue;
auto nca = std::make_shared<NCA>(file);
+ // TODO(DarkLordZach): Add proper Rev1+ Support
+ if (nca->IsUpdate())
+ continue;
+ if (nca->GetType() == NCAContentType::Program) {
+ program_nca_status = nca->GetStatus();
+ }
if (nca->GetStatus() == Loader::ResultStatus::Success) {
ncas.push_back(std::move(nca));
} else {
diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h
index a03d5264e..54ab828d1 100644
--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -59,6 +59,7 @@ public:
explicit XCI(VirtualFile file);
Loader::ResultStatus GetStatus() const;
+ Loader::ResultStatus GetProgramNCAStatus() const;
u8 GetFormatVersion() const;
@@ -90,6 +91,7 @@ private:
GamecardHeader header{};
Loader::ResultStatus status;
+ Loader::ResultStatus program_nca_status;
std::vector<VirtualDir> partitions;
std::vector<std::shared_ptr<NCA>> ncas;
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 47afcad9b..e8b5d6ece 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -178,7 +178,7 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
return std::static_pointer_cast<VfsFile>(out);
}
case NCASectionCryptoType::XTS:
- // TODO(DarkLordZach): Implement XTSEncryptionLayer.
+ // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
default:
LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
static_cast<u8>(s_header.raw.header.crypto_type));
@@ -258,6 +258,10 @@ NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
file->ReadBytes(sections.data(), length_sections, SECTION_HEADER_OFFSET);
}
+ is_update = std::find_if(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
+ return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
+ }) != sections.end();
+
for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
auto section = sections[i];
@@ -358,6 +362,10 @@ VirtualFile NCA::GetBaseFile() const {
return file;
}
+bool NCA::IsUpdate() const {
+ return is_update;
+}
+
bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
return false;
}
diff --git a/src/core/file_sys/content_archive.h b/src/core/file_sys/content_archive.h
index 4b74c54ec..b961cfde7 100644
--- a/src/core/file_sys/content_archive.h
+++ b/src/core/file_sys/content_archive.h
@@ -93,6 +93,8 @@ public:
VirtualFile GetBaseFile() const;
+ bool IsUpdate() const;
+
protected:
bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
@@ -111,6 +113,7 @@ private:
NCAHeader header{};
bool has_rights_id{};
+ bool is_update{};
Loader::ResultStatus status{};
diff --git a/src/core/file_sys/registered_cache.cpp b/src/core/file_sys/registered_cache.cpp
index e90dc6695..a02efc71e 100644
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -254,6 +254,8 @@ RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction
Refresh();
}
+RegisteredCache::~RegisteredCache() = default;
+
bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
return GetEntryRaw(title_id, type) != nullptr;
}
@@ -262,6 +264,18 @@ bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
return GetEntryRaw(entry) != nullptr;
}
+VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
+ const auto id = GetNcaIDFromMetadata(title_id, type);
+ if (id == boost::none)
+ return nullptr;
+
+ return GetFileAtID(id.get());
+}
+
+VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
+ return GetEntryUnparsed(entry.title_id, entry.type);
+}
+
VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) const {
const auto id = GetNcaIDFromMetadata(title_id, type);
if (id == boost::none)
diff --git a/src/core/file_sys/registered_cache.h b/src/core/file_sys/registered_cache.h
index a7c51a59c..7b8955dfa 100644
--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -63,12 +63,16 @@ public:
explicit RegisteredCache(VirtualDir dir,
RegisteredCacheParsingFunction parsing_function =
[](const VirtualFile& file, const NcaID& id) { return file; });
+ ~RegisteredCache();
void Refresh();
bool HasEntry(u64 title_id, ContentRecordType type) const;
bool HasEntry(RegisteredCacheEntry entry) const;
+ VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
+ VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
+
VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp
index d1acf379f..d66a9c9a4 100644
--- a/src/core/file_sys/sdmc_factory.cpp
+++ b/src/core/file_sys/sdmc_factory.cpp
@@ -3,14 +3,27 @@
// Refer to the license.txt file included.
#include <memory>
+#include "core/file_sys/registered_cache.h"
#include "core/file_sys/sdmc_factory.h"
+#include "core/file_sys/xts_archive.h"
namespace FileSys {
-SDMCFactory::SDMCFactory(VirtualDir dir) : dir(std::move(dir)) {}
+SDMCFactory::SDMCFactory(VirtualDir dir_)
+ : dir(std::move(dir_)), contents(std::make_shared<RegisteredCache>(
+ GetOrCreateDirectoryRelative(dir, "/Nintendo/Contents/registered"),
+ [](const VirtualFile& file, const NcaID& id) {
+ return std::make_shared<NAX>(file, id)->GetDecrypted();
+ })) {}
+
+SDMCFactory::~SDMCFactory() = default;
ResultVal<VirtualDir> SDMCFactory::Open() {
return MakeResult<VirtualDir>(dir);
}
+std::shared_ptr<RegisteredCache> SDMCFactory::GetSDMCContents() const {
+ return contents;
+}
+
} // namespace FileSys
diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h
index 245060690..ea12149de 100644
--- a/src/core/file_sys/sdmc_factory.h
+++ b/src/core/file_sys/sdmc_factory.h
@@ -4,20 +4,27 @@
#pragma once
+#include <memory>
#include "core/file_sys/vfs.h"
#include "core/hle/result.h"
namespace FileSys {
+class RegisteredCache;
+
/// File system interface to the SDCard archive
class SDMCFactory {
public:
explicit SDMCFactory(VirtualDir dir);
+ ~SDMCFactory();
ResultVal<VirtualDir> Open();
+ std::shared_ptr<RegisteredCache> GetSDMCContents() const;
private:
VirtualDir dir;
+
+ std::shared_ptr<RegisteredCache> contents;
};
} // namespace FileSys
diff --git a/src/core/file_sys/vfs.cpp b/src/core/file_sys/vfs.cpp
index b915b4c11..146c839f4 100644
--- a/src/core/file_sys/vfs.cpp
+++ b/src/core/file_sys/vfs.cpp
@@ -462,4 +462,11 @@ bool VfsRawCopy(VirtualFile src, VirtualFile dest) {
std::vector<u8> data = src->ReadAllBytes();
return dest->WriteBytes(data, 0) == data.size();
}
+
+VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path) {
+ const auto res = rel->GetDirectoryRelative(path);
+ if (res == nullptr)
+ return rel->CreateDirectoryRelative(path);
+ return res;
+}
} // namespace FileSys
diff --git a/src/core/file_sys/vfs.h b/src/core/file_sys/vfs.h
index 22db08b59..5142a3e86 100644
--- a/src/core/file_sys/vfs.h
+++ b/src/core/file_sys/vfs.h
@@ -318,4 +318,8 @@ bool DeepEquals(const VirtualFile& file1, const VirtualFile& file2, size_t block
// directory of src/dest.
bool VfsRawCopy(VirtualFile src, VirtualFile dest);
+// Checks if the directory at path relative to rel exists. If it does, returns that. If it does not
+// it attempts to create it and returns the new dir or nullptr on failure.
+VirtualDir GetOrCreateDirectoryRelative(const VirtualDir& rel, std::string_view path);
+
} // namespace FileSys
diff --git a/src/core/file_sys/xts_archive.cpp b/src/core/file_sys/xts_archive.cpp
new file mode 100644
index 000000000..552835738
--- /dev/null
+++ b/src/core/file_sys/xts_archive.cpp
@@ -0,0 +1,169 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <regex>
+#include <string>
+#include <mbedtls/md.h>
+#include <mbedtls/sha256.h>
+#include "common/assert.h"
+#include "common/hex_util.h"
+#include "common/logging/log.h"
+#include "core/crypto/aes_util.h"
+#include "core/crypto/xts_encryption_layer.h"
+#include "core/file_sys/partition_filesystem.h"
+#include "core/file_sys/vfs_offset.h"
+#include "core/file_sys/xts_archive.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+constexpr u64 NAX_HEADER_PADDING_SIZE = 0x4000;
+
+template <typename SourceData, typename SourceKey, typename Destination>
+static bool CalculateHMAC256(Destination* out, const SourceKey* key, size_t key_length,
+ const SourceData* data, size_t data_length) {
+ mbedtls_md_context_t context;
+ mbedtls_md_init(&context);
+
+ const auto key_f = reinterpret_cast<const u8*>(key);
+ const std::vector<u8> key_v(key_f, key_f + key_length);
+
+ if (mbedtls_md_setup(&context, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1) ||
+ mbedtls_md_hmac_starts(&context, reinterpret_cast<const u8*>(key), key_length) ||
+ mbedtls_md_hmac_update(&context, reinterpret_cast<const u8*>(data), data_length) ||
+ mbedtls_md_hmac_finish(&context, reinterpret_cast<u8*>(out))) {
+ mbedtls_md_free(&context);
+ return false;
+ }
+
+ mbedtls_md_free(&context);
+ return true;
+}
+
+NAX::NAX(VirtualFile file_) : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
+ std::string path = FileUtil::SanitizePath(file->GetFullPath());
+ static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
+ std::regex_constants::ECMAScript |
+ std::regex_constants::icase);
+ std::smatch match;
+ if (!std::regex_search(path, match, nax_path_regex)) {
+ status = Loader::ResultStatus::ErrorBadNAXFilePath;
+ return;
+ }
+
+ std::string two_dir = match[1];
+ std::string nca_id = match[2];
+ std::transform(two_dir.begin(), two_dir.end(), two_dir.begin(), ::toupper);
+ std::transform(nca_id.begin(), nca_id.end(), nca_id.begin(), ::tolower);
+
+ status = Parse(fmt::format("/registered/{}/{}.nca", two_dir, nca_id));
+}
+
+NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
+ : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
+ Core::Crypto::SHA256Hash hash{};
+ mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
+ status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
+ Common::HexArrayToString(nca_id, false)));
+}
+
+Loader::ResultStatus NAX::Parse(std::string_view path) {
+ if (file->ReadObject(header.get()) != sizeof(NAXHeader))
+ return Loader::ResultStatus::ErrorBadNAXHeader;
+
+ if (header->magic != Common::MakeMagic('N', 'A', 'X', '0'))
+ return Loader::ResultStatus::ErrorBadNAXHeader;
+
+ if (file->GetSize() < NAX_HEADER_PADDING_SIZE + header->file_size)
+ return Loader::ResultStatus::ErrorIncorrectNAXFileSize;
+
+ keys.DeriveSDSeedLazy();
+ std::array<Core::Crypto::Key256, 2> sd_keys{};
+ const auto sd_keys_res = Core::Crypto::DeriveSDKeys(sd_keys, keys);
+ if (sd_keys_res != Loader::ResultStatus::Success) {
+ return sd_keys_res;
+ }
+
+ const auto enc_keys = header->key_area;
+
+ size_t i = 0;
+ for (; i < sd_keys.size(); ++i) {
+ std::array<Core::Crypto::Key128, 2> nax_keys{};
+ if (!CalculateHMAC256(nax_keys.data(), sd_keys[i].data(), 0x10, std::string(path).c_str(),
+ path.size())) {
+ return Loader::ResultStatus::ErrorNAXKeyHMACFailed;
+ }
+
+ for (size_t j = 0; j < nax_keys.size(); ++j) {
+ Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(nax_keys[j],
+ Core::Crypto::Mode::ECB);
+ cipher.Transcode(enc_keys[j].data(), 0x10, header->key_area[j].data(),
+ Core::Crypto::Op::Decrypt);
+ }
+
+ Core::Crypto::SHA256Hash validation{};
+ if (!CalculateHMAC256(validation.data(), &header->magic, 0x60, sd_keys[i].data() + 0x10,
+ 0x10)) {
+ return Loader::ResultStatus::ErrorNAXValidationHMACFailed;
+ }
+ if (header->hmac == validation)
+ break;
+ }
+
+ if (i == 2) {
+ return Loader::ResultStatus::ErrorNAXKeyDerivationFailed;
+ }
+
+ type = static_cast<NAXContentType>(i);
+
+ Core::Crypto::Key256 final_key{};
+ std::memcpy(final_key.data(), &header->key_area, final_key.size());
+ const auto enc_file =
+ std::make_shared<OffsetVfsFile>(file, header->file_size, NAX_HEADER_PADDING_SIZE);
+ dec_file = std::make_shared<Core::Crypto::XTSEncryptionLayer>(enc_file, final_key);
+
+ return Loader::ResultStatus::Success;
+}
+
+Loader::ResultStatus NAX::GetStatus() const {
+ return status;
+}
+
+VirtualFile NAX::GetDecrypted() const {
+ return dec_file;
+}
+
+std::shared_ptr<NCA> NAX::AsNCA() const {
+ if (type == NAXContentType::NCA)
+ return std::make_shared<NCA>(GetDecrypted());
+ return nullptr;
+}
+
+NAXContentType NAX::GetContentType() const {
+ return type;
+}
+
+std::vector<std::shared_ptr<VfsFile>> NAX::GetFiles() const {
+ return {dec_file};
+}
+
+std::vector<std::shared_ptr<VfsDirectory>> NAX::GetSubdirectories() const {
+ return {};
+}
+
+std::string NAX::GetName() const {
+ return file->GetName();
+}
+
+std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
+ return file->GetContainingDirectory();
+}
+
+bool NAX::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
+ return false;
+}
+} // namespace FileSys
diff --git a/src/core/file_sys/xts_archive.h b/src/core/file_sys/xts_archive.h
new file mode 100644
index 000000000..55d2154a6
--- /dev/null
+++ b/src/core/file_sys/xts_archive.h
@@ -0,0 +1,69 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <vector>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/crypto/key_manager.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/vfs.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+struct NAXHeader {
+ std::array<u8, 0x20> hmac;
+ u64_le magic;
+ std::array<Core::Crypto::Key128, 2> key_area;
+ u64_le file_size;
+ INSERT_PADDING_BYTES(0x30);
+};
+static_assert(sizeof(NAXHeader) == 0x80, "NAXHeader has incorrect size.");
+
+enum class NAXContentType : u8 {
+ Save = 0,
+ NCA = 1,
+};
+
+class NAX : public ReadOnlyVfsDirectory {
+public:
+ explicit NAX(VirtualFile file);
+ explicit NAX(VirtualFile file, std::array<u8, 0x10> nca_id);
+
+ Loader::ResultStatus GetStatus() const;
+
+ VirtualFile GetDecrypted() const;
+
+ std::shared_ptr<NCA> AsNCA() const;
+
+ NAXContentType GetContentType() const;
+
+ std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+
+ std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+
+ std::string GetName() const override;
+
+ std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+
+protected:
+ bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
+
+private:
+ Loader::ResultStatus Parse(std::string_view path);
+
+ std::unique_ptr<NAXHeader> header;
+
+ VirtualFile file;
+ Loader::ResultStatus status;
+ NAXContentType type;
+
+ VirtualFile dec_file;
+
+ Core::Crypto::KeyManager keys;
+};
+} // namespace FileSys
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-14 19:46:57 +0200