fssystem: rework for yuzu style

This commit is contained in:
Liam 2023-08-12 15:18:55 -04:00
parent 0398b34370
commit 50eee9b218
34 changed files with 344 additions and 339 deletions

View file

@ -12,7 +12,9 @@ namespace Common {
template <typename T> template <typename T>
requires std::is_integral_v<T> requires std::is_integral_v<T>
[[nodiscard]] constexpr T AlignUp(T value, size_t size) { [[nodiscard]] constexpr T AlignUp(T value_, size_t size) {
using U = typename std::make_unsigned_t<T>;
auto value{static_cast<U>(value_)};
auto mod{static_cast<T>(value % size)}; auto mod{static_cast<T>(value % size)};
value -= mod; value -= mod;
return static_cast<T>(mod == T{0} ? value : value + size); return static_cast<T>(mod == T{0} ? value : value + size);
@ -26,7 +28,9 @@ template <typename T>
template <typename T> template <typename T>
requires std::is_integral_v<T> requires std::is_integral_v<T>
[[nodiscard]] constexpr T AlignDown(T value, size_t size) { [[nodiscard]] constexpr T AlignDown(T value_, size_t size) {
using U = typename std::make_unsigned_t<T>;
const auto value{static_cast<U>(value_)};
return static_cast<T>(value - value % size); return static_cast<T>(value - value % size);
} }

View file

@ -71,7 +71,7 @@ std::vector<u8> DecompressDataLZ4(std::span<const u8> compressed, std::size_t un
return uncompressed; return uncompressed;
} }
int DecompressLZ4(void* dst, size_t dst_size, const void* src, size_t src_size) { int DecompressDataLZ4(void* dst, size_t dst_size, const void* src, size_t src_size) {
// This is just a thin wrapper around LZ4. // This is just a thin wrapper around LZ4.
return LZ4_decompress_safe(reinterpret_cast<const char*>(src), reinterpret_cast<char*>(dst), return LZ4_decompress_safe(reinterpret_cast<const char*>(src), reinterpret_cast<char*>(dst),
static_cast<int>(src_size), static_cast<int>(dst_size)); static_cast<int>(src_size), static_cast<int>(dst_size));

View file

@ -56,6 +56,6 @@ namespace Common::Compression {
[[nodiscard]] std::vector<u8> DecompressDataLZ4(std::span<const u8> compressed, [[nodiscard]] std::vector<u8> DecompressDataLZ4(std::span<const u8> compressed,
std::size_t uncompressed_size); std::size_t uncompressed_size);
int DecompressLZ4(void* dst, size_t dst_size, const void* src, size_t src_size); [[nodiscard]] int DecompressDataLZ4(void* dst, size_t dst_size, const void* src, size_t src_size);
} // namespace Common::Compression } // namespace Common::Compression

View file

@ -29,8 +29,8 @@ constexpr std::array partition_names{
XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index) XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
: file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA}, : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
partitions(partition_names.size()), partitions_raw(partition_names.size()), partitions(partition_names.size()),
keys{Core::Crypto::KeyManager::Instance()} { partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
if (file->ReadObject(&header) != sizeof(GamecardHeader)) { if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
status = Loader::ResultStatus::ErrorBadXCIHeader; status = Loader::ResultStatus::ErrorBadXCIHeader;
return; return;

View file

@ -31,7 +31,7 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
reader = std::make_shared<NcaReader>(); reader = std::make_shared<NcaReader>();
if (Result rc = if (Result rc =
reader->Initialize(file, GetCryptoConfiguration(), *GetNcaCompressionConfiguration()); reader->Initialize(file, GetCryptoConfiguration(), GetNcaCompressionConfiguration());
R_FAILED(rc)) { R_FAILED(rc)) {
if (rc != ResultInvalidNcaSignature) { if (rc != ResultInvalidNcaSignature) {
LOG_ERROR(Loader, "File reader errored out during header read: {:#x}", LOG_ERROR(Loader, "File reader errored out during header read: {:#x}",
@ -102,7 +102,6 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
} }
} }
// TODO: Is this correct??
if (header_reader.GetEncryptionType() == NcaFsHeader::EncryptionType::AesCtrEx) { if (header_reader.GetEncryptionType() == NcaFsHeader::EncryptionType::AesCtrEx) {
is_update = true; is_update = true;
} }
@ -144,16 +143,14 @@ VirtualDir NCA::GetParentDirectory() const {
} }
NCAContentType NCA::GetType() const { NCAContentType NCA::GetType() const {
u8 type = static_cast<u8>(reader->GetContentType()); return static_cast<NCAContentType>(reader->GetContentType());
return static_cast<NCAContentType>(type);
} }
u64 NCA::GetTitleId() const { u64 NCA::GetTitleId() const {
if (is_update) { if (is_update) {
return reader->GetProgramId() | 0x800; return reader->GetProgramId() | 0x800;
} else {
return reader->GetProgramId();
} }
return reader->GetProgramId();
} }
RightsId NCA::GetRightsId() const { RightsId NCA::GetRightsId() const {

View file

@ -126,7 +126,7 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e
auto cur_entry = *visitor.Get<Entry>(); auto cur_entry = *visitor.Get<Entry>();
while (cur_entry.GetOffset() < end_offset) { while (cur_entry.GetOffset() < end_offset) {
// Try to write the entry to the out list // Try to write the entry to the out list.
if (entry_count != 0) { if (entry_count != 0) {
if (count >= entry_count) { if (count >= entry_count) {
break; break;
@ -152,7 +152,6 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e
size_t AesCtrCounterExtendedStorage::Read(u8* buffer, size_t size, size_t offset) const { size_t AesCtrCounterExtendedStorage::Read(u8* buffer, size_t size, size_t offset) const {
// Validate preconditions. // Validate preconditions.
ASSERT(offset >= 0);
ASSERT(this->IsInitialized()); ASSERT(this->IsInitialized());
// Allow zero size. // Allow zero size.

View file

@ -70,14 +70,6 @@ public:
static Result CreateSoftwareDecryptor(std::unique_ptr<IDecryptor>* out); static Result CreateSoftwareDecryptor(std::unique_ptr<IDecryptor>* out);
private:
mutable BucketTree m_table;
VirtualFile m_data_storage;
std::array<u8, KeySize> m_key;
u32 m_secure_value;
s64 m_counter_offset;
std::unique_ptr<IDecryptor> m_decryptor;
public: public:
AesCtrCounterExtendedStorage() AesCtrCounterExtendedStorage()
: m_table(), m_data_storage(), m_secure_value(), m_counter_offset(), m_decryptor() {} : m_table(), m_data_storage(), m_secure_value(), m_counter_offset(), m_decryptor() {}
@ -109,6 +101,14 @@ public:
private: private:
Result Initialize(const void* key, size_t key_size, u32 secure_value, VirtualFile data_storage, Result Initialize(const void* key, size_t key_size, u32 secure_value, VirtualFile data_storage,
VirtualFile table_storage); VirtualFile table_storage);
private:
mutable BucketTree m_table;
VirtualFile m_data_storage;
std::array<u8, KeySize> m_key;
u32 m_secure_value;
s64 m_counter_offset;
std::unique_ptr<IDecryptor> m_decryptor;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -22,12 +22,6 @@ public:
static constexpr size_t KeySize = 0x10; static constexpr size_t KeySize = 0x10;
static constexpr size_t IvSize = 0x10; static constexpr size_t IvSize = 0x10;
private:
VirtualFile m_base_storage;
std::array<u8, KeySize> m_key;
std::array<u8, IvSize> m_iv;
mutable std::optional<Core::Crypto::AESCipher<Core::Crypto::Key128>> m_cipher;
public: public:
static void MakeIv(void* dst, size_t dst_size, u64 upper, s64 offset); static void MakeIv(void* dst, size_t dst_size, u64 upper, s64 offset);
@ -38,6 +32,12 @@ public:
virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; virtual size_t Read(u8* buffer, size_t size, size_t offset) const override;
virtual size_t Write(const u8* buffer, size_t size, size_t offset) override; virtual size_t Write(const u8* buffer, size_t size, size_t offset) override;
virtual size_t GetSize() const override; virtual size_t GetSize() const override;
private:
VirtualFile m_base_storage;
std::array<u8, KeySize> m_key;
std::array<u8, IvSize> m_iv;
mutable std::optional<Core::Crypto::AESCipher<Core::Crypto::Key128>> m_cipher;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -20,14 +20,6 @@ public:
static constexpr size_t KeySize = 0x20; static constexpr size_t KeySize = 0x20;
static constexpr size_t IvSize = 0x10; static constexpr size_t IvSize = 0x10;
private:
VirtualFile m_base_storage;
std::array<u8, KeySize> m_key;
std::array<u8, IvSize> m_iv;
const size_t m_block_size;
std::mutex m_mutex;
mutable std::optional<Core::Crypto::AESCipher<Core::Crypto::Key256>> m_cipher;
public: public:
static void MakeAesXtsIv(void* dst, size_t dst_size, s64 offset, size_t block_size); static void MakeAesXtsIv(void* dst, size_t dst_size, s64 offset, size_t block_size);
@ -37,6 +29,14 @@ public:
virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; virtual size_t Read(u8* buffer, size_t size, size_t offset) const override;
virtual size_t GetSize() const override; virtual size_t GetSize() const override;
private:
VirtualFile m_base_storage;
std::array<u8, KeySize> m_key;
std::array<u8, IvSize> m_iv;
const size_t m_block_size;
std::mutex m_mutex;
mutable std::optional<Core::Crypto::AESCipher<Core::Crypto::Key256>> m_cipher;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -34,7 +34,7 @@ public:
virtual size_t Read(u8* buffer, size_t size, size_t offset) const override { virtual size_t Read(u8* buffer, size_t size, size_t offset) const override {
// Allocate a work buffer on stack. // Allocate a work buffer on stack.
alignas(DataAlignMax) char work_buf[DataAlign]; alignas(DataAlignMax) std::array<char, DataAlign> work_buf;
// Succeed if zero size. // Succeed if zero size.
if (size == 0) { if (size == 0) {
@ -47,13 +47,13 @@ public:
s64 bs_size = this->GetSize(); s64 bs_size = this->GetSize();
ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size))); ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size)));
return AlignmentMatchingStorageImpl::Read(m_base_storage, work_buf, sizeof(work_buf), return AlignmentMatchingStorageImpl::Read(m_base_storage, work_buf.data(), work_buf.size(),
DataAlign, BufferAlign, offset, buffer, size); DataAlign, BufferAlign, offset, buffer, size);
} }
virtual size_t Write(const u8* buffer, size_t size, size_t offset) override { virtual size_t Write(const u8* buffer, size_t size, size_t offset) override {
// Allocate a work buffer on stack. // Allocate a work buffer on stack.
alignas(DataAlignMax) char work_buf[DataAlign]; alignas(DataAlignMax) std::array<char, DataAlign> work_buf;
// Succeed if zero size. // Succeed if zero size.
if (size == 0) { if (size == 0) {
@ -66,7 +66,7 @@ public:
s64 bs_size = this->GetSize(); s64 bs_size = this->GetSize();
ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size))); ASSERT(R_SUCCEEDED(IStorage::CheckAccessRange(offset, size, bs_size)));
return AlignmentMatchingStorageImpl::Write(m_base_storage, work_buf, sizeof(work_buf), return AlignmentMatchingStorageImpl::Write(m_base_storage, work_buf.data(), work_buf.size(),
DataAlign, BufferAlign, offset, buffer, size); DataAlign, BufferAlign, offset, buffer, size);
} }

View file

@ -226,7 +226,7 @@ Result BucketTree::Initialize(VirtualFile node_storage, VirtualFile entry_storag
m_offset_cache.offsets.end_offset = end_offset; m_offset_cache.offsets.end_offset = end_offset;
m_offset_cache.is_initialized = true; m_offset_cache.is_initialized = true;
// Cancel guard. // We succeeded.
R_SUCCEED(); R_SUCCEED();
} }
@ -357,7 +357,7 @@ Result BucketTree::Visitor::MoveNext() {
entry_index = 0; entry_index = 0;
} else { } else {
m_entry_index = 1; m_entry_index = -1;
} }
// Read the new entry. // Read the new entry.

View file

@ -77,11 +77,6 @@ public:
}; };
class ContinuousReadingInfo { class ContinuousReadingInfo {
private:
size_t m_read_size;
s32 m_skip_count;
bool m_done;
public: public:
constexpr ContinuousReadingInfo() : m_read_size(), m_skip_count(), m_done() {} constexpr ContinuousReadingInfo() : m_read_size(), m_skip_count(), m_done() {}
@ -119,15 +114,17 @@ public:
constexpr bool CanDo() const { constexpr bool CanDo() const {
return m_read_size > 0; return m_read_size > 0;
} }
private:
size_t m_read_size;
s32 m_skip_count;
bool m_done;
}; };
private: private:
class NodeBuffer { class NodeBuffer {
YUZU_NON_COPYABLE(NodeBuffer); YUZU_NON_COPYABLE(NodeBuffer);
private:
void* m_header;
public: public:
NodeBuffer() : m_header() {} NodeBuffer() : m_header() {}
@ -187,6 +184,9 @@ private:
static_assert(sizeof(T) == sizeof(NodeHeader)); static_assert(sizeof(T) == sizeof(NodeHeader));
return reinterpret_cast<T*>(m_header); return reinterpret_cast<T*>(m_header);
} }
private:
void* m_header;
}; };
private: private:
@ -218,51 +218,6 @@ private:
offset_count_per_node); offset_count_per_node);
} }
public:
static constexpr s64 QueryHeaderStorageSize() {
return sizeof(Header);
}
static constexpr s64 QueryNodeStorageSize(size_t node_size, size_t entry_size,
s32 entry_count) {
ASSERT(entry_size >= sizeof(s64));
ASSERT(node_size >= entry_size + sizeof(NodeHeader));
ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
ASSERT(Common::IsPowerOfTwo(node_size));
ASSERT(entry_count >= 0);
if (entry_count <= 0) {
return 0;
}
return (1 + GetNodeL2Count(node_size, entry_size, entry_count)) *
static_cast<s64>(node_size);
}
static constexpr s64 QueryEntryStorageSize(size_t node_size, size_t entry_size,
s32 entry_count) {
ASSERT(entry_size >= sizeof(s64));
ASSERT(node_size >= entry_size + sizeof(NodeHeader));
ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
ASSERT(Common::IsPowerOfTwo(node_size));
ASSERT(entry_count >= 0);
if (entry_count <= 0) {
return 0;
}
return GetEntrySetCount(node_size, entry_size, entry_count) * static_cast<s64>(node_size);
}
private:
mutable VirtualFile m_node_storage;
mutable VirtualFile m_entry_storage;
NodeBuffer m_node_l1;
size_t m_node_size;
size_t m_entry_size;
s32 m_entry_count;
s32 m_offset_count;
s32 m_entry_set_count;
OffsetCache m_offset_cache;
public: public:
BucketTree() BucketTree()
: m_node_storage(), m_entry_storage(), m_node_l1(), m_node_size(), m_entry_size(), : m_node_storage(), m_entry_storage(), m_node_l1(), m_node_size(), m_entry_size(),
@ -299,6 +254,40 @@ public:
R_SUCCEED(); R_SUCCEED();
} }
public:
static constexpr s64 QueryHeaderStorageSize() {
return sizeof(Header);
}
static constexpr s64 QueryNodeStorageSize(size_t node_size, size_t entry_size,
s32 entry_count) {
ASSERT(entry_size >= sizeof(s64));
ASSERT(node_size >= entry_size + sizeof(NodeHeader));
ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
ASSERT(Common::IsPowerOfTwo(node_size));
ASSERT(entry_count >= 0);
if (entry_count <= 0) {
return 0;
}
return (1 + GetNodeL2Count(node_size, entry_size, entry_count)) *
static_cast<s64>(node_size);
}
static constexpr s64 QueryEntryStorageSize(size_t node_size, size_t entry_size,
s32 entry_count) {
ASSERT(entry_size >= sizeof(s64));
ASSERT(node_size >= entry_size + sizeof(NodeHeader));
ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
ASSERT(Common::IsPowerOfTwo(node_size));
ASSERT(entry_count >= 0);
if (entry_count <= 0) {
return 0;
}
return GetEntrySetCount(node_size, entry_size, entry_count) * static_cast<s64>(node_size);
}
private: private:
template <typename EntryType> template <typename EntryType>
struct ContinuousReadingParam { struct ContinuousReadingParam {
@ -327,35 +316,23 @@ private:
} }
Result EnsureOffsetCache(); Result EnsureOffsetCache();
private:
mutable VirtualFile m_node_storage;
mutable VirtualFile m_entry_storage;
NodeBuffer m_node_l1;
size_t m_node_size;
size_t m_entry_size;
s32 m_entry_count;
s32 m_offset_count;
s32 m_entry_set_count;
OffsetCache m_offset_cache;
}; };
class BucketTree::Visitor { class BucketTree::Visitor {
YUZU_NON_COPYABLE(Visitor); YUZU_NON_COPYABLE(Visitor);
YUZU_NON_MOVEABLE(Visitor); YUZU_NON_MOVEABLE(Visitor);
private:
friend class BucketTree;
union EntrySetHeader {
NodeHeader header;
struct Info {
s32 index;
s32 count;
s64 end;
s64 start;
} info;
static_assert(std::is_trivial_v<Info>);
};
static_assert(std::is_trivial_v<EntrySetHeader>);
private:
const BucketTree* m_tree;
BucketTree::Offsets m_offsets;
void* m_entry;
s32 m_entry_index;
s32 m_entry_set_count;
EntrySetHeader m_entry_set;
public: public:
constexpr Visitor() constexpr Visitor()
: m_tree(), m_entry(), m_entry_index(-1), m_entry_set_count(), m_entry_set{} {} : m_tree(), m_entry(), m_entry_index(-1), m_entry_set_count(), m_entry_set{} {}
@ -412,6 +389,28 @@ private:
Result FindEntry(s64 virtual_address, s32 entry_set_index); Result FindEntry(s64 virtual_address, s32 entry_set_index);
Result FindEntryWithBuffer(s64 virtual_address, s32 entry_set_index, char* buffer); Result FindEntryWithBuffer(s64 virtual_address, s32 entry_set_index, char* buffer);
Result FindEntryWithoutBuffer(s64 virtual_address, s32 entry_set_index); Result FindEntryWithoutBuffer(s64 virtual_address, s32 entry_set_index);
private:
friend class BucketTree;
union EntrySetHeader {
NodeHeader header;
struct Info {
s32 index;
s32 count;
s64 end;
s64 start;
} info;
static_assert(std::is_trivial_v<Info>);
};
static_assert(std::is_trivial_v<EntrySetHeader>);
const BucketTree* m_tree;
BucketTree::Offsets m_offsets;
void* m_entry;
s32 m_entry_index;
s32 m_entry_set_count;
EntrySetHeader m_entry_set;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -50,13 +50,6 @@ private:
YUZU_NON_COPYABLE(CompressedStorageCore); YUZU_NON_COPYABLE(CompressedStorageCore);
YUZU_NON_MOVEABLE(CompressedStorageCore); YUZU_NON_MOVEABLE(CompressedStorageCore);
private:
size_t m_block_size_max;
size_t m_continuous_reading_size_max;
BucketTree m_table;
VirtualFile m_data_storage;
GetDecompressorFunction m_get_decompressor_function;
public: public:
CompressedStorageCore() : m_table(), m_data_storage() {} CompressedStorageCore() : m_table(), m_data_storage() {}
@ -296,7 +289,7 @@ private:
ASSERT(offset >= 0); ASSERT(offset >= 0);
ASSERT(this->IsInitialized()); ASSERT(this->IsInitialized());
// Succeed immediately, if we hvae nothing to read. // Succeed immediately, if we have nothing to read.
R_SUCCEED_IF(size == 0); R_SUCCEED_IF(size == 0);
// Declare read lambda. // Declare read lambda.
@ -307,10 +300,13 @@ private:
u32 physical_size; u32 physical_size;
u32 virtual_size; u32 virtual_size;
}; };
Entries entries[EntriesCountMax]; std::array<Entries, EntriesCountMax> entries;
s32 entry_count = 0; s32 entry_count = 0;
Entry prev_entry = { Entry prev_entry = {
.virt_offset = -1, .virt_offset = -1,
.phys_offset{},
.compression_type{},
.phys_size{},
}; };
bool will_allocate_pooled_buffer = false; bool will_allocate_pooled_buffer = false;
s64 required_access_physical_offset = 0; s64 required_access_physical_offset = 0;
@ -594,7 +590,7 @@ private:
} }
required_access_physical_size += physical_size + gap_from_prev; required_access_physical_size += physical_size + gap_from_prev;
// Create an entry. to access the data storage. // Create an entry to access the data storage.
entries[entry_count++] = { entries[entry_count++] = {
.compression_type = entry.compression_type, .compression_type = entry.compression_type,
.gap_from_prev = static_cast<u32>(gap_from_prev), .gap_from_prev = static_cast<u32>(gap_from_prev),
@ -621,7 +617,7 @@ private:
.virtual_size = static_cast<u32>(read_size), .virtual_size = static_cast<u32>(read_size),
}; };
} else { } else {
// We have no entries, we we can just perform the read. // We have no entries, so we can just perform the read.
const Result rc = const Result rc =
read_func(static_cast<size_t>(read_size), read_func(static_cast<size_t>(read_size),
[&](void* dst, size_t dst_size) -> Result { [&](void* dst, size_t dst_size) -> Result {
@ -668,6 +664,13 @@ private:
bool IsInitialized() const { bool IsInitialized() const {
return m_table.IsInitialized(); return m_table.IsInitialized();
} }
private:
size_t m_block_size_max;
size_t m_continuous_reading_size_max;
BucketTree m_table;
VirtualFile m_data_storage;
GetDecompressorFunction m_get_decompressor_function;
}; };
class CacheManager { class CacheManager {
@ -687,9 +690,6 @@ private:
}; };
static_assert(std::is_trivial_v<AccessRange>); static_assert(std::is_trivial_v<AccessRange>);
private:
s64 m_storage_size = 0;
public: public:
CacheManager() = default; CacheManager() = default;
@ -890,11 +890,10 @@ private:
R_SUCCEED(); R_SUCCEED();
} }
};
private: private:
mutable CompressedStorageCore m_core; s64 m_storage_size = 0;
mutable CacheManager m_cache_manager; };
public: public:
CompressedStorage() = default; CompressedStorage() = default;
@ -955,6 +954,10 @@ public:
return 0; return 0;
} }
} }
private:
mutable CompressedStorageCore m_core;
mutable CacheManager m_cache_manager;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -9,7 +9,7 @@ namespace FileSys {
namespace { namespace {
Result DecompressLz4(void* dst, size_t dst_size, const void* src, size_t src_size) { Result DecompressLz4(void* dst, size_t dst_size, const void* src, size_t src_size) {
auto result = Common::Compression::DecompressLZ4(dst, dst_size, src, src_size); auto result = Common::Compression::DecompressDataLZ4(dst, dst_size, src, src_size);
R_UNLESS(static_cast<size_t>(result) == dst_size, ResultUnexpectedInCompressedStorageC); R_UNLESS(static_cast<size_t>(result) == dst_size, ResultUnexpectedInCompressedStorageC);
R_SUCCEED(); R_SUCCEED();
} }
@ -23,14 +23,14 @@ constexpr DecompressorFunction GetNcaDecompressorFunction(CompressionType type)
} }
} }
constexpr NcaCompressionConfiguration g_nca_compression_configuration{ } // namespace
const NcaCompressionConfiguration& GetNcaCompressionConfiguration() {
static const NcaCompressionConfiguration configuration = {
.get_decompressor = GetNcaDecompressorFunction, .get_decompressor = GetNcaDecompressorFunction,
}; };
} // namespace return configuration;
const NcaCompressionConfiguration* GetNcaCompressionConfiguration() {
return std::addressof(g_nca_compression_configuration);
} }
} // namespace FileSys } // namespace FileSys

View file

@ -7,6 +7,6 @@
namespace FileSys { namespace FileSys {
const NcaCompressionConfiguration* GetNcaCompressionConfiguration(); const NcaCompressionConfiguration& GetNcaCompressionConfiguration();
} }

View file

@ -48,7 +48,15 @@ void GenerateKey(void* dst_key, size_t dst_key_size, const void* src_key, size_t
const NcaCryptoConfiguration& GetCryptoConfiguration() { const NcaCryptoConfiguration& GetCryptoConfiguration() {
static const NcaCryptoConfiguration configuration = { static const NcaCryptoConfiguration configuration = {
.header_1_sign_key_moduli{},
.header_1_sign_key_public_exponent{},
.key_area_encryption_key_source{},
.header_encryption_key_source{},
.header_encrypted_encryption_keys{},
.generate_key = GenerateKey, .generate_key = GenerateKey,
.verify_sign1{},
.is_plaintext_header_available{},
.is_available_sw_key{},
}; };
return configuration; return configuration;

View file

@ -24,7 +24,7 @@ static_assert(alignof(HierarchicalIntegrityVerificationLevelInformation) == 0x4)
struct HierarchicalIntegrityVerificationInformation { struct HierarchicalIntegrityVerificationInformation {
u32 max_layers; u32 max_layers;
HierarchicalIntegrityVerificationLevelInformation info[IntegrityMaxLayerCount - 1]; std::array<HierarchicalIntegrityVerificationLevelInformation, IntegrityMaxLayerCount - 1> info;
HashSalt seed; HashSalt seed;
s64 GetLayeredHashSize() const { s64 GetLayeredHashSize() const {
@ -52,7 +52,7 @@ static_assert(std::is_trivial_v<HierarchicalIntegrityVerificationMetaInformation
struct HierarchicalIntegrityVerificationSizeSet { struct HierarchicalIntegrityVerificationSizeSet {
s64 control_size; s64 control_size;
s64 master_hash_size; s64 master_hash_size;
s64 layered_hash_sizes[IntegrityMaxLayerCount - 2]; std::array<s64, IntegrityMaxLayerCount - 2> layered_hash_sizes;
}; };
static_assert(std::is_trivial_v<HierarchicalIntegrityVerificationSizeSet>); static_assert(std::is_trivial_v<HierarchicalIntegrityVerificationSizeSet>);
@ -60,13 +60,6 @@ class HierarchicalIntegrityVerificationStorage : public IReadOnlyStorage {
YUZU_NON_COPYABLE(HierarchicalIntegrityVerificationStorage); YUZU_NON_COPYABLE(HierarchicalIntegrityVerificationStorage);
YUZU_NON_MOVEABLE(HierarchicalIntegrityVerificationStorage); YUZU_NON_MOVEABLE(HierarchicalIntegrityVerificationStorage);
private:
friend struct HierarchicalIntegrityVerificationMetaInformation;
protected:
static constexpr s64 HashSize = 256 / 8;
static constexpr size_t MaxLayers = IntegrityMaxLayerCount;
public: public:
using GenerateRandomFunction = void (*)(void* dst, size_t size); using GenerateRandomFunction = void (*)(void* dst, size_t size);
@ -83,7 +76,7 @@ public:
}; };
private: private:
VirtualFile m_storages[DataStorage + 1]; std::array<VirtualFile, DataStorage + 1> m_storages;
public: public:
void SetMasterHashStorage(VirtualFile s) { void SetMasterHashStorage(VirtualFile s) {
@ -114,19 +107,6 @@ public:
} }
}; };
private:
static GenerateRandomFunction s_generate_random;
static void SetGenerateRandomFunction(GenerateRandomFunction func) {
s_generate_random = func;
}
private:
std::shared_ptr<IntegrityVerificationStorage> m_verify_storages[MaxLayers - 1];
VirtualFile m_buffer_storages[MaxLayers - 1];
s64 m_data_size;
s32 m_max_layers;
public: public:
HierarchicalIntegrityVerificationStorage(); HierarchicalIntegrityVerificationStorage();
virtual ~HierarchicalIntegrityVerificationStorage() override { virtual ~HierarchicalIntegrityVerificationStorage() override {
@ -159,6 +139,26 @@ public:
static constexpr s8 GetDefaultDataCacheBufferLevel(u32 max_layers) { static constexpr s8 GetDefaultDataCacheBufferLevel(u32 max_layers) {
return static_cast<s8>(16 + max_layers - 2); return static_cast<s8>(16 + max_layers - 2);
} }
protected:
static constexpr s64 HashSize = 256 / 8;
static constexpr size_t MaxLayers = IntegrityMaxLayerCount;
private:
static GenerateRandomFunction s_generate_random;
static void SetGenerateRandomFunction(GenerateRandomFunction func) {
s_generate_random = func;
}
private:
friend struct HierarchicalIntegrityVerificationMetaInformation;
private:
std::array<std::shared_ptr<IntegrityVerificationStorage>, MaxLayers - 1> m_verify_storages;
std::array<VirtualFile, MaxLayers - 1> m_buffer_storages;
s64 m_data_size;
s32 m_max_layers;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -19,15 +19,6 @@ public:
static constexpr s32 LayerCount = 3; static constexpr s32 LayerCount = 3;
static constexpr size_t HashSize = 256 / 8; static constexpr size_t HashSize = 256 / 8;
private:
VirtualFile m_base_storage;
s64 m_base_storage_size;
char* m_hash_buffer;
size_t m_hash_buffer_size;
s32 m_hash_target_block_size;
s32 m_log_size_ratio;
std::mutex m_mutex;
public: public:
HierarchicalSha256Storage() : m_mutex() {} HierarchicalSha256Storage() : m_mutex() {}
@ -39,6 +30,15 @@ public:
} }
virtual size_t Read(u8* buffer, size_t length, size_t offset) const override; virtual size_t Read(u8* buffer, size_t length, size_t offset) const override;
private:
VirtualFile m_base_storage;
s64 m_base_storage_size;
char* m_hash_buffer;
size_t m_hash_buffer_size;
s32 m_hash_target_block_size;
s32 m_log_size_ratio;
std::mutex m_mutex;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -72,7 +72,7 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
auto cur_entry = *visitor.Get<Entry>(); auto cur_entry = *visitor.Get<Entry>();
while (cur_entry.GetVirtualOffset() < end_offset) { while (cur_entry.GetVirtualOffset() < end_offset) {
// Try to write the entry to the out list // Try to write the entry to the out list.
if (entry_count != 0) { if (entry_count != 0) {
if (count >= entry_count) { if (count >= entry_count) {
break; break;
@ -98,7 +98,6 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
size_t IndirectStorage::Read(u8* buffer, size_t size, size_t offset) const { size_t IndirectStorage::Read(u8* buffer, size_t size, size_t offset) const {
// Validate pre-conditions. // Validate pre-conditions.
ASSERT(offset >= 0);
ASSERT(this->IsInitialized()); ASSERT(this->IsInitialized());
ASSERT(buffer != nullptr); ASSERT(buffer != nullptr);

View file

@ -21,27 +21,27 @@ public:
static constexpr size_t NodeSize = 16_KiB; static constexpr size_t NodeSize = 16_KiB;
struct Entry { struct Entry {
u8 virt_offset[sizeof(s64)]; std::array<u8, sizeof(s64)> virt_offset;
u8 phys_offset[sizeof(s64)]; std::array<u8, sizeof(s64)> phys_offset;
s32 storage_index; s32 storage_index;
void SetVirtualOffset(const s64& ofs) { void SetVirtualOffset(const s64& ofs) {
std::memcpy(this->virt_offset, std::addressof(ofs), sizeof(s64)); std::memcpy(this->virt_offset.data(), std::addressof(ofs), sizeof(s64));
} }
s64 GetVirtualOffset() const { s64 GetVirtualOffset() const {
s64 offset; s64 offset;
std::memcpy(std::addressof(offset), this->virt_offset, sizeof(s64)); std::memcpy(std::addressof(offset), this->virt_offset.data(), sizeof(s64));
return offset; return offset;
} }
void SetPhysicalOffset(const s64& ofs) { void SetPhysicalOffset(const s64& ofs) {
std::memcpy(this->phys_offset, std::addressof(ofs), sizeof(s64)); std::memcpy(this->phys_offset.data(), std::addressof(ofs), sizeof(s64));
} }
s64 GetPhysicalOffset() const { s64 GetPhysicalOffset() const {
s64 offset; s64 offset;
std::memcpy(std::addressof(offset), this->phys_offset, sizeof(s64)); std::memcpy(std::addressof(offset), this->phys_offset.data(), sizeof(s64));
return offset; return offset;
} }
}; };
@ -61,43 +61,6 @@ public:
}; };
static_assert(std::is_trivial_v<EntryData>); static_assert(std::is_trivial_v<EntryData>);
private:
struct ContinuousReadingEntry {
static constexpr size_t FragmentSizeMax = 4_KiB;
IndirectStorage::Entry entry;
s64 GetVirtualOffset() const {
return this->entry.GetVirtualOffset();
}
s64 GetPhysicalOffset() const {
return this->entry.GetPhysicalOffset();
}
bool IsFragment() const {
return this->entry.storage_index != 0;
}
};
static_assert(std::is_trivial_v<ContinuousReadingEntry>);
public:
static constexpr s64 QueryHeaderStorageSize() {
return BucketTree::QueryHeaderStorageSize();
}
static constexpr s64 QueryNodeStorageSize(s32 entry_count) {
return BucketTree::QueryNodeStorageSize(NodeSize, sizeof(Entry), entry_count);
}
static constexpr s64 QueryEntryStorageSize(s32 entry_count) {
return BucketTree::QueryEntryStorageSize(NodeSize, sizeof(Entry), entry_count);
}
private:
mutable BucketTree m_table;
std::array<VirtualFile, StorageCount> m_data_storage;
public: public:
IndirectStorage() : m_table(), m_data_storage() {} IndirectStorage() : m_table(), m_data_storage() {}
virtual ~IndirectStorage() { virtual ~IndirectStorage() {
@ -131,7 +94,7 @@ public:
s64 size); s64 size);
virtual size_t GetSize() const override { virtual size_t GetSize() const override {
BucketTree::Offsets offsets; BucketTree::Offsets offsets{};
m_table.GetOffsets(std::addressof(offsets)); m_table.GetOffsets(std::addressof(offsets));
return offsets.end_offset; return offsets.end_offset;
@ -139,6 +102,19 @@ public:
virtual size_t Read(u8* buffer, size_t size, size_t offset) const override; virtual size_t Read(u8* buffer, size_t size, size_t offset) const override;
public:
static constexpr s64 QueryHeaderStorageSize() {
return BucketTree::QueryHeaderStorageSize();
}
static constexpr s64 QueryNodeStorageSize(s32 entry_count) {
return BucketTree::QueryNodeStorageSize(NodeSize, sizeof(Entry), entry_count);
}
static constexpr s64 QueryEntryStorageSize(s32 entry_count) {
return BucketTree::QueryEntryStorageSize(NodeSize, sizeof(Entry), entry_count);
}
protected: protected:
BucketTree& GetEntryTable() { BucketTree& GetEntryTable() {
return m_table; return m_table;
@ -151,6 +127,30 @@ protected:
template <bool ContinuousCheck, bool RangeCheck, typename F> template <bool ContinuousCheck, bool RangeCheck, typename F>
Result OperatePerEntry(s64 offset, s64 size, F func); Result OperatePerEntry(s64 offset, s64 size, F func);
private:
struct ContinuousReadingEntry {
static constexpr size_t FragmentSizeMax = 4_KiB;
IndirectStorage::Entry entry;
s64 GetVirtualOffset() const {
return this->entry.GetVirtualOffset();
}
s64 GetPhysicalOffset() const {
return this->entry.GetPhysicalOffset();
}
bool IsFragment() const {
return this->entry.storage_index != 0;
}
};
static_assert(std::is_trivial_v<ContinuousReadingEntry>);
private:
mutable BucketTree m_table;
std::array<VirtualFile, StorageCount> m_data_storage;
}; };
template <bool ContinuousCheck, bool RangeCheck, typename F> template <bool ContinuousCheck, bool RangeCheck, typename F>

View file

@ -13,11 +13,6 @@ constexpr inline size_t IntegrityLayerCountRomFs = 7;
constexpr inline size_t IntegrityHashLayerBlockSize = 16_KiB; constexpr inline size_t IntegrityHashLayerBlockSize = 16_KiB;
class IntegrityRomFsStorage : public IReadOnlyStorage { class IntegrityRomFsStorage : public IReadOnlyStorage {
private:
HierarchicalIntegrityVerificationStorage m_integrity_storage;
Hash m_master_hash;
std::shared_ptr<ArrayVfsFile<sizeof(Hash)>> m_master_hash_storage;
public: public:
IntegrityRomFsStorage() {} IntegrityRomFsStorage() {}
virtual ~IntegrityRomFsStorage() override { virtual ~IntegrityRomFsStorage() override {
@ -37,6 +32,11 @@ public:
virtual size_t GetSize() const override { virtual size_t GetSize() const override {
return m_integrity_storage.GetSize(); return m_integrity_storage.GetSize();
} }
private:
HierarchicalIntegrityVerificationStorage m_integrity_storage;
Hash m_master_hash;
std::shared_ptr<ArrayVfsFile<sizeof(Hash)>> m_master_hash_storage;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -8,7 +8,7 @@ namespace FileSys {
constexpr inline u32 ILog2(u32 val) { constexpr inline u32 ILog2(u32 val) {
ASSERT(val > 0); ASSERT(val > 0);
return ((sizeof(u32) * 8) - 1 - std::countl_zero<u32>(val)); return static_cast<u32>((sizeof(u32) * 8) - 1 - std::countl_zero<u32>(val));
} }
void IntegrityVerificationStorage::Initialize(VirtualFile hs, VirtualFile ds, s64 verif_block_size, void IntegrityVerificationStorage::Initialize(VirtualFile hs, VirtualFile ds, s64 verif_block_size,

View file

@ -18,19 +18,10 @@ public:
static constexpr s64 HashSize = 256 / 8; static constexpr s64 HashSize = 256 / 8;
struct BlockHash { struct BlockHash {
u8 hash[HashSize]; std::array<u8, HashSize> hash;
}; };
static_assert(std::is_trivial_v<BlockHash>); static_assert(std::is_trivial_v<BlockHash>);
private:
VirtualFile m_hash_storage;
VirtualFile m_data_storage;
s64 m_verification_block_size;
s64 m_verification_block_order;
s64 m_upper_layer_verification_block_size;
s64 m_upper_layer_verification_block_order;
bool m_is_real_data;
public: public:
IntegrityVerificationStorage() IntegrityVerificationStorage()
: m_verification_block_size(0), m_verification_block_order(0), : m_verification_block_size(0), m_verification_block_order(0),
@ -60,6 +51,15 @@ private:
ASSERT(hash != nullptr); ASSERT(hash != nullptr);
return (hash->hash[HashSize - 1] & 0x80) != 0; return (hash->hash[HashSize - 1] & 0x80) != 0;
} }
private:
VirtualFile m_hash_storage;
VirtualFile m_data_storage;
s64 m_verification_block_size;
s64 m_verification_block_order;
s64 m_upper_layer_verification_block_size;
s64 m_upper_layer_verification_block_order;
bool m_is_real_data;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include "core/file_sys/fssystem/fs_i_storage.h" #include "core/file_sys/fssystem/fs_i_storage.h"
@ -8,11 +11,6 @@ class MemoryResourceBufferHoldStorage : public IStorage {
YUZU_NON_COPYABLE(MemoryResourceBufferHoldStorage); YUZU_NON_COPYABLE(MemoryResourceBufferHoldStorage);
YUZU_NON_MOVEABLE(MemoryResourceBufferHoldStorage); YUZU_NON_MOVEABLE(MemoryResourceBufferHoldStorage);
private:
VirtualFile m_storage;
void* m_buffer;
size_t m_buffer_size;
public: public:
MemoryResourceBufferHoldStorage(VirtualFile storage, size_t buffer_size) MemoryResourceBufferHoldStorage(VirtualFile storage, size_t buffer_size)
: m_storage(std::move(storage)), m_buffer(::operator new(buffer_size)), : m_storage(std::move(storage)), m_buffer(::operator new(buffer_size)),
@ -53,6 +51,11 @@ public:
return m_storage->Write(buffer, size, offset); return m_storage->Write(buffer, size, offset);
} }
private:
VirtualFile m_storage;
void* m_buffer;
size_t m_buffer_size;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -228,7 +228,7 @@ Result NcaFileSystemDriver::OpenStorageImpl(VirtualFile* out, NcaFsHeaderReader*
// Process indirect layer. // Process indirect layer.
if (patch_info.HasIndirectTable()) { if (patch_info.HasIndirectTable()) {
// Create the indirect meta storage // Create the indirect meta storage.
VirtualFile indirect_storage_meta_storage = patch_meta_indirect_meta_storage; VirtualFile indirect_storage_meta_storage = patch_meta_indirect_meta_storage;
if (indirect_storage_meta_storage == nullptr) { if (indirect_storage_meta_storage == nullptr) {
// If we don't have a meta storage, we must not have a patch meta hash layer. // If we don't have a meta storage, we must not have a patch meta hash layer.

View file

@ -37,11 +37,13 @@ struct NcaCryptoConfiguration {
static constexpr size_t KeyGenerationMax = 32; static constexpr size_t KeyGenerationMax = 32;
const u8* header_1_sign_key_moduli[Header1SignatureKeyGenerationMax + 1]; std::array<const u8*, Header1SignatureKeyGenerationMax + 1> header_1_sign_key_moduli;
u8 header_1_sign_key_public_exponent[Rsa2048KeyPublicExponentSize]; std::array<u8, Rsa2048KeyPublicExponentSize> header_1_sign_key_public_exponent;
u8 key_area_encryption_key_source[KeyAreaEncryptionKeyIndexCount][Aes128KeySize]; std::array<std::array<u8, Aes128KeySize>, KeyAreaEncryptionKeyIndexCount>
u8 header_encryption_key_source[Aes128KeySize]; key_area_encryption_key_source;
u8 header_encrypted_encryption_keys[HeaderEncryptionKeyCount][Aes128KeySize]; std::array<u8, Aes128KeySize> header_encryption_key_source;
std::array<std::array<u8, Aes128KeySize>, HeaderEncryptionKeyCount>
header_encrypted_encryption_keys;
KeyGenerationFunction generate_key; KeyGenerationFunction generate_key;
VerifySign1Function verify_sign1; VerifySign1Function verify_sign1;
bool is_plaintext_header_available; bool is_plaintext_header_available;
@ -89,18 +91,6 @@ class NcaReader {
YUZU_NON_COPYABLE(NcaReader); YUZU_NON_COPYABLE(NcaReader);
YUZU_NON_MOVEABLE(NcaReader); YUZU_NON_MOVEABLE(NcaReader);
private:
NcaHeader m_header;
u8 m_decryption_keys[NcaHeader::DecryptionKey_Count][NcaCryptoConfiguration::Aes128KeySize];
VirtualFile m_body_storage;
VirtualFile m_header_storage;
u8 m_external_decryption_key[NcaCryptoConfiguration::Aes128KeySize];
bool m_is_software_aes_prioritized;
bool m_is_available_sw_key;
NcaHeader::EncryptionType m_header_encryption_type;
bool m_is_header_sign1_signature_valid;
GetDecompressorFunction m_get_decompressor;
public: public:
NcaReader(); NcaReader();
~NcaReader(); ~NcaReader();
@ -147,16 +137,26 @@ public:
bool GetHeaderSign1Valid() const; bool GetHeaderSign1Valid() const;
void GetHeaderSign2(void* dst, size_t size) const; void GetHeaderSign2(void* dst, size_t size) const;
private:
NcaHeader m_header;
std::array<std::array<u8, NcaCryptoConfiguration::Aes128KeySize>,
NcaHeader::DecryptionKey_Count>
m_decryption_keys;
VirtualFile m_body_storage;
VirtualFile m_header_storage;
std::array<u8, NcaCryptoConfiguration::Aes128KeySize> m_external_decryption_key;
bool m_is_software_aes_prioritized;
bool m_is_available_sw_key;
NcaHeader::EncryptionType m_header_encryption_type;
bool m_is_header_sign1_signature_valid;
GetDecompressorFunction m_get_decompressor;
}; };
class NcaFsHeaderReader { class NcaFsHeaderReader {
YUZU_NON_COPYABLE(NcaFsHeaderReader); YUZU_NON_COPYABLE(NcaFsHeaderReader);
YUZU_NON_MOVEABLE(NcaFsHeaderReader); YUZU_NON_MOVEABLE(NcaFsHeaderReader);
private:
NcaFsHeader m_data;
s32 m_fs_index;
public: public:
NcaFsHeaderReader() : m_fs_index(-1) { NcaFsHeaderReader() : m_fs_index(-1) {
std::memset(std::addressof(m_data), 0, sizeof(m_data)); std::memset(std::addressof(m_data), 0, sizeof(m_data));
@ -200,6 +200,10 @@ public:
NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo(); NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo();
const NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo() const; const NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo() const;
NcaFsHeader::MetaDataHashType GetSparseMetaHashType() const; NcaFsHeader::MetaDataHashType GetSparseMetaHashType() const;
private:
NcaFsHeader m_data;
s32 m_fs_index;
}; };
class NcaFileSystemDriver { class NcaFileSystemDriver {
@ -236,10 +240,6 @@ private:
None = 1, None = 1,
}; };
private:
std::shared_ptr<NcaReader> m_original_reader;
std::shared_ptr<NcaReader> m_reader;
public: public:
static Result SetupFsHeaderReader(NcaFsHeaderReader* out, const NcaReader& reader, static Result SetupFsHeaderReader(NcaFsHeaderReader* out, const NcaReader& reader,
s32 fs_index); s32 fs_index);
@ -355,6 +355,10 @@ public:
VirtualFile* out_meta, VirtualFile base_storage, VirtualFile* out_meta, VirtualFile base_storage,
const NcaCompressionInfo& compression_info, const NcaCompressionInfo& compression_info,
GetDecompressorFunction get_decompressor); GetDecompressorFunction get_decompressor);
private:
std::shared_ptr<NcaReader> m_original_reader;
std::shared_ptr<NcaReader> m_reader;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -53,24 +53,27 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat
// Generate keys for header. // Generate keys for header.
using AesXtsStorageForNcaHeader = AesXtsStorage; using AesXtsStorageForNcaHeader = AesXtsStorage;
constexpr const s32 HeaderKeyTypeValues[NcaCryptoConfiguration::HeaderEncryptionKeyCount] = { constexpr std::array<s32, NcaCryptoConfiguration::HeaderEncryptionKeyCount>
HeaderKeyTypeValues = {
static_cast<s32>(KeyType::NcaHeaderKey1), static_cast<s32>(KeyType::NcaHeaderKey1),
static_cast<s32>(KeyType::NcaHeaderKey2), static_cast<s32>(KeyType::NcaHeaderKey2),
}; };
u8 header_decryption_keys[NcaCryptoConfiguration::HeaderEncryptionKeyCount] std::array<std::array<u8, NcaCryptoConfiguration::Aes128KeySize>,
[NcaCryptoConfiguration::Aes128KeySize]; NcaCryptoConfiguration::HeaderEncryptionKeyCount>
header_decryption_keys;
for (size_t i = 0; i < NcaCryptoConfiguration::HeaderEncryptionKeyCount; i++) { for (size_t i = 0; i < NcaCryptoConfiguration::HeaderEncryptionKeyCount; i++) {
crypto_cfg.generate_key(header_decryption_keys[i], AesXtsStorageForNcaHeader::KeySize, crypto_cfg.generate_key(header_decryption_keys[i].data(),
crypto_cfg.header_encrypted_encryption_keys[i], AesXtsStorageForNcaHeader::KeySize,
crypto_cfg.header_encrypted_encryption_keys[i].data(),
AesXtsStorageForNcaHeader::KeySize, HeaderKeyTypeValues[i]); AesXtsStorageForNcaHeader::KeySize, HeaderKeyTypeValues[i]);
} }
// Create the header storage. // Create the header storage.
const u8 header_iv[AesXtsStorageForNcaHeader::IvSize] = {}; std::array<u8, AesXtsStorageForNcaHeader::IvSize> header_iv = {};
work_header_storage = std::make_unique<AesXtsStorageForNcaHeader>( work_header_storage = std::make_unique<AesXtsStorageForNcaHeader>(
base_storage, header_decryption_keys[0], header_decryption_keys[1], base_storage, header_decryption_keys[0].data(), header_decryption_keys[1].data(),
AesXtsStorageForNcaHeader::KeySize, header_iv, AesXtsStorageForNcaHeader::IvSize, AesXtsStorageForNcaHeader::KeySize, header_iv.data(), AesXtsStorageForNcaHeader::IvSize,
NcaHeader::XtsBlockSize); NcaHeader::XtsBlockSize);
// Check that we successfully created the storage. // Check that we successfully created the storage.
@ -94,20 +97,6 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat
m_header_encryption_type = NcaHeader::EncryptionType::None; m_header_encryption_type = NcaHeader::EncryptionType::None;
} }
// Validate the fixed key signature.
if (m_header.header1_signature_key_generation >
NcaCryptoConfiguration::Header1SignatureKeyGenerationMax) {
LOG_CRITICAL(Frontend,
"NcaCryptoConfiguration::Header1SignatureKeyGenerationMax = {}, "
"m_header.header1_signature_key_generation = {}",
NcaCryptoConfiguration::Header1SignatureKeyGenerationMax,
m_header.header1_signature_key_generation);
}
R_UNLESS(m_header.header1_signature_key_generation <=
NcaCryptoConfiguration::Header1SignatureKeyGenerationMax,
ResultInvalidNcaHeader1SignatureKeyGeneration);
// Verify the header sign1. // Verify the header sign1.
if (crypto_cfg.verify_sign1 != nullptr) { if (crypto_cfg.verify_sign1 != nullptr) {
const u8* sig = m_header.header_sign_1.data(); const u8* sig = m_header.header_sign_1.data();
@ -138,31 +127,31 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat
if (std::memcmp(ZeroRightsId.data(), m_header.rights_id.data(), NcaHeader::RightsIdSize) == 0) { if (std::memcmp(ZeroRightsId.data(), m_header.rights_id.data(), NcaHeader::RightsIdSize) == 0) {
// If we don't, then we don't have an external key, so we need to generate decryption keys. // If we don't, then we don't have an external key, so we need to generate decryption keys.
crypto_cfg.generate_key( crypto_cfg.generate_key(
m_decryption_keys[NcaHeader::DecryptionKey_AesCtr], Aes128KeySize, m_decryption_keys[NcaHeader::DecryptionKey_AesCtr].data(), Aes128KeySize,
m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtr * Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtr * Aes128KeySize,
Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
crypto_cfg.generate_key( crypto_cfg.generate_key(
m_decryption_keys[NcaHeader::DecryptionKey_AesXts1], Aes128KeySize, m_decryption_keys[NcaHeader::DecryptionKey_AesXts1].data(), Aes128KeySize,
m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts1 * Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts1 * Aes128KeySize,
Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
crypto_cfg.generate_key( crypto_cfg.generate_key(
m_decryption_keys[NcaHeader::DecryptionKey_AesXts2], Aes128KeySize, m_decryption_keys[NcaHeader::DecryptionKey_AesXts2].data(), Aes128KeySize,
m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts2 * Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesXts2 * Aes128KeySize,
Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
crypto_cfg.generate_key( crypto_cfg.generate_key(
m_decryption_keys[NcaHeader::DecryptionKey_AesCtrEx], Aes128KeySize, m_decryption_keys[NcaHeader::DecryptionKey_AesCtrEx].data(), Aes128KeySize,
m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtrEx * Aes128KeySize, m_header.encrypted_key_area.data() + NcaHeader::DecryptionKey_AesCtrEx * Aes128KeySize,
Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration())); Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
// Copy the hardware speed emulation key. // Copy the hardware speed emulation key.
std::memcpy(m_decryption_keys[NcaHeader::DecryptionKey_AesCtrHw], std::memcpy(m_decryption_keys[NcaHeader::DecryptionKey_AesCtrHw].data(),
m_header.encrypted_key_area.data() + m_header.encrypted_key_area.data() +
NcaHeader::DecryptionKey_AesCtrHw * Aes128KeySize, NcaHeader::DecryptionKey_AesCtrHw * Aes128KeySize,
Aes128KeySize); Aes128KeySize);
} }
// Clear the external decryption key. // Clear the external decryption key.
std::memset(m_external_decryption_key, 0, sizeof(m_external_decryption_key)); std::memset(m_external_decryption_key.data(), 0, m_external_decryption_key.size());
// Set software key availability. // Set software key availability.
m_is_available_sw_key = crypto_cfg.is_available_sw_key; m_is_available_sw_key = crypto_cfg.is_available_sw_key;
@ -304,7 +293,7 @@ void NcaReader::GetEncryptedKey(void* dst, size_t size) const {
const void* NcaReader::GetDecryptionKey(s32 index) const { const void* NcaReader::GetDecryptionKey(s32 index) const {
ASSERT(m_body_storage != nullptr); ASSERT(m_body_storage != nullptr);
ASSERT(0 <= index && index < NcaHeader::DecryptionKey_Count); ASSERT(0 <= index && index < NcaHeader::DecryptionKey_Count);
return m_decryption_keys[index]; return m_decryption_keys[index].data();
} }
bool NcaReader::HasValidInternalKey() const { bool NcaReader::HasValidInternalKey() const {
@ -339,14 +328,14 @@ bool NcaReader::HasExternalDecryptionKey() const {
} }
const void* NcaReader::GetExternalDecryptionKey() const { const void* NcaReader::GetExternalDecryptionKey() const {
return m_external_decryption_key; return m_external_decryption_key.data();
} }
void NcaReader::SetExternalDecryptionKey(const void* src, size_t size) { void NcaReader::SetExternalDecryptionKey(const void* src, size_t size) {
ASSERT(src != nullptr); ASSERT(src != nullptr);
ASSERT(size == sizeof(m_external_decryption_key)); ASSERT(size == sizeof(m_external_decryption_key));
std::memcpy(m_external_decryption_key, src, sizeof(m_external_decryption_key)); std::memcpy(m_external_decryption_key.data(), src, sizeof(m_external_decryption_key));
} }
void NcaReader::GetRawData(void* dst, size_t dst_size) const { void NcaReader::GetRawData(void* dst, size_t dst_size) const {

View file

@ -18,27 +18,6 @@ constexpr inline size_t BufferPoolWorkSize = 320;
class PooledBuffer { class PooledBuffer {
YUZU_NON_COPYABLE(PooledBuffer); YUZU_NON_COPYABLE(PooledBuffer);
private:
char* m_buffer;
size_t m_size;
private:
static size_t GetAllocatableSizeMaxCore(bool large);
public:
static size_t GetAllocatableSizeMax() {
return GetAllocatableSizeMaxCore(false);
}
static size_t GetAllocatableParticularlyLargeSizeMax() {
return GetAllocatableSizeMaxCore(true);
}
private:
void Swap(PooledBuffer& rhs) {
std::swap(m_buffer, rhs.m_buffer);
std::swap(m_size, rhs.m_size);
}
public: public:
// Constructor/Destructor. // Constructor/Destructor.
constexpr PooledBuffer() : m_buffer(), m_size() {} constexpr PooledBuffer() : m_buffer(), m_size() {}
@ -89,8 +68,28 @@ public:
return m_size; return m_size;
} }
public:
static size_t GetAllocatableSizeMax() {
return GetAllocatableSizeMaxCore(false);
}
static size_t GetAllocatableParticularlyLargeSizeMax() {
return GetAllocatableSizeMaxCore(true);
}
private: private:
static size_t GetAllocatableSizeMaxCore(bool large);
private:
void Swap(PooledBuffer& rhs) {
std::swap(m_buffer, rhs.m_buffer);
std::swap(m_size, rhs.m_size);
}
void AllocateCore(size_t ideal_size, size_t required_size, bool large); void AllocateCore(size_t ideal_size, size_t required_size, bool large);
private:
char* m_buffer;
size_t m_size;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -7,7 +7,6 @@ namespace FileSys {
size_t SparseStorage::Read(u8* buffer, size_t size, size_t offset) const { size_t SparseStorage::Read(u8* buffer, size_t size, size_t offset) const {
// Validate preconditions. // Validate preconditions.
ASSERT(offset >= 0);
ASSERT(this->IsInitialized()); ASSERT(this->IsInitialized());
ASSERT(buffer != nullptr); ASSERT(buffer != nullptr);

View file

@ -22,7 +22,6 @@ private:
} }
virtual size_t Read(u8* buffer, size_t size, size_t offset) const override { virtual size_t Read(u8* buffer, size_t size, size_t offset) const override {
ASSERT(offset >= 0);
ASSERT(buffer != nullptr || size == 0); ASSERT(buffer != nullptr || size == 0);
if (size > 0) { if (size > 0) {
@ -33,9 +32,6 @@ private:
} }
}; };
private:
VirtualFile m_zero_storage;
public: public:
SparseStorage() : IndirectStorage(), m_zero_storage(std::make_shared<ZeroStorage>()) {} SparseStorage() : IndirectStorage(), m_zero_storage(std::make_shared<ZeroStorage>()) {}
virtual ~SparseStorage() {} virtual ~SparseStorage() {}
@ -68,6 +64,9 @@ private:
void SetZeroStorage() { void SetZeroStorage() {
return this->SetStorage(1, m_zero_storage, 0, std::numeric_limits<s64>::max()); return this->SetStorage(1, m_zero_storage, 0, std::numeric_limits<s64>::max());
} }
private:
VirtualFile m_zero_storage;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -17,11 +17,6 @@ public:
s64 size; s64 size;
}; };
private:
VirtualFile m_inside_region_storage;
VirtualFile m_outside_region_storage;
Region m_region;
public: public:
RegionSwitchStorage(VirtualFile&& i, VirtualFile&& o, Region r) RegionSwitchStorage(VirtualFile&& i, VirtualFile&& o, Region r)
: m_inside_region_storage(std::move(i)), m_outside_region_storage(std::move(o)), : m_inside_region_storage(std::move(i)), m_outside_region_storage(std::move(o)),
@ -75,6 +70,11 @@ private:
return false; return false;
} }
} }
private:
VirtualFile m_inside_region_storage;
VirtualFile m_outside_region_storage;
Region m_region;
}; };
} // namespace FileSys } // namespace FileSys

View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "core/file_sys/fssystem/fssystem_utility.h" #include "core/file_sys/fssystem/fssystem_utility.h"
namespace FileSys { namespace FileSys {

View file

@ -19,9 +19,9 @@
namespace FileSys { namespace FileSys {
NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_) NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_)
: file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_), : file(std::move(file_)), expected_program_id(title_id_),
status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)), program_index(program_index_), status{Loader::ResultStatus::Success},
keys{Core::Crypto::KeyManager::Instance()} { pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
if (pfs->GetStatus() != Loader::ResultStatus::Success) { if (pfs->GetStatus() != Loader::ResultStatus::Success) {
status = pfs->GetStatus(); status = pfs->GetStatus();
return; return;

View file

@ -310,8 +310,8 @@ private:
class IFileSystem final : public ServiceFramework<IFileSystem> { class IFileSystem final : public ServiceFramework<IFileSystem> {
public: public:
explicit IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_) explicit IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_)
: ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, : ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, size{std::move(
size{std::move(size_)} { size_)} {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IFileSystem::CreateFile, "CreateFile"}, {0, &IFileSystem::CreateFile, "CreateFile"},
{1, &IFileSystem::DeleteFile, "DeleteFile"}, {1, &IFileSystem::DeleteFile, "DeleteFile"},