30 files changed, 335 insertions, 334 deletions

diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index 54b53d020..4920905a6 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -29,8 +29,8 @@ constexpr std::array partition_names{
 
 XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()), partitions_raw(partition_names.size()),
-      keys{Core::Crypto::KeyManager::Instance()} {
+      partitions(partition_names.size()),
+      partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 2361b169e..44e6852fe 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -31,7 +31,7 @@ NCA::NCA(VirtualFile file_, const NCA* base_nca)
 
     reader = std::make_shared<NcaReader>();
     if (Result rc =
-            reader->Initialize(file, GetCryptoConfiguration(), *GetNcaCompressionConfiguration());
+            reader->Initialize(file, GetCryptoConfiguration(), GetNcaCompressionConfiguration());
         R_FAILED(rc)) {
         if (rc != ResultInvalidNcaSignature) {
             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) {
             is_update = true;
         }
@@ -144,16 +143,14 @@ VirtualDir NCA::GetParentDirectory() const {
 }
 
 NCAContentType NCA::GetType() const {
-    u8 type = static_cast<u8>(reader->GetContentType());
-    return static_cast<NCAContentType>(type);
+    return static_cast<NCAContentType>(reader->GetContentType());
 }
 
 u64 NCA::GetTitleId() const {
     if (is_update) {
         return reader->GetProgramId() | 0x800;
-    } else {
-        return reader->GetProgramId();
     }
+    return reader->GetProgramId();
 }
 
 RightsId NCA::GetRightsId() const {
diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp
index bf189c606..f25c95472 100644
--- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp
+++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp
@@ -126,7 +126,7 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e
 
     auto cur_entry = *visitor.Get<Entry>();
     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 (count >= entry_count) {
                 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 {
     // Validate preconditions.
-    ASSERT(offset >= 0);
     ASSERT(this->IsInitialized());
 
     // Allow zero size.
diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h
index a79904fad..d0e9ceed0 100644
--- a/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h
@@ -70,14 +70,6 @@ public:
 
     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:
     AesCtrCounterExtendedStorage()
         : m_table(), m_data_storage(), m_secure_value(), m_counter_offset(), m_decryptor() {}
@@ -109,6 +101,14 @@ public:
 private:
     Result Initialize(const void* key, size_t key_size, u32 secure_value, VirtualFile data_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
diff --git a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h
index bceb1f9ad..339e49697 100644
--- a/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_aes_ctr_storage.h
@@ -22,12 +22,6 @@ public:
     static constexpr size_t KeySize = 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:
     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 Write(const u8* buffer, size_t size, size_t offset) 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
diff --git a/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h b/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h
index 2307a2659..f342efb57 100644
--- a/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_aes_xts_storage.h
@@ -20,14 +20,6 @@ public:
     static constexpr size_t KeySize = 0x20;
     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:
     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 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
diff --git a/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h b/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h
index 27d34fd17..f96691d03 100644
--- a/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_alignment_matching_storage.h
@@ -34,7 +34,7 @@ public:
 
     virtual size_t Read(u8* buffer, size_t size, size_t offset) const override {
         // Allocate a work buffer on stack.
-        alignas(DataAlignMax) char work_buf[DataAlign];
+        alignas(DataAlignMax) std::array<char, DataAlign> work_buf;
 
         // Succeed if zero size.
         if (size == 0) {
@@ -47,13 +47,13 @@ public:
         s64 bs_size = this->GetSize();
         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);
     }
 
     virtual size_t Write(const u8* buffer, size_t size, size_t offset) override {
         // Allocate a work buffer on stack.
-        alignas(DataAlignMax) char work_buf[DataAlign];
+        alignas(DataAlignMax) std::array<char, DataAlign> work_buf;
 
         // Succeed if zero size.
         if (size == 0) {
@@ -66,7 +66,7 @@ public:
         s64 bs_size = this->GetSize();
         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);
     }
 
diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp
index 699a366f1..af8541009 100644
--- a/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp
+++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.cpp
@@ -226,7 +226,7 @@ Result BucketTree::Initialize(VirtualFile node_storage, VirtualFile entry_storag
     m_offset_cache.offsets.end_offset = end_offset;
     m_offset_cache.is_initialized = true;
 
-    // Cancel guard.
+    // We succeeded.
     R_SUCCEED();
 }
 
@@ -357,7 +357,7 @@ Result BucketTree::Visitor::MoveNext() {
 
         entry_index = 0;
     } else {
-        m_entry_index = 1;
+        m_entry_index = -1;
     }
 
     // Read the new entry.
diff --git a/src/core/file_sys/fssystem/fssystem_bucket_tree.h b/src/core/file_sys/fssystem/fssystem_bucket_tree.h
index 74a2f7583..46850cd48 100644
--- a/src/core/file_sys/fssystem/fssystem_bucket_tree.h
+++ b/src/core/file_sys/fssystem/fssystem_bucket_tree.h
@@ -77,11 +77,6 @@ public:
     };
 
     class ContinuousReadingInfo {
-    private:
-        size_t m_read_size;
-        s32 m_skip_count;
-        bool m_done;
-
     public:
         constexpr ContinuousReadingInfo() : m_read_size(), m_skip_count(), m_done() {}
 
@@ -119,15 +114,17 @@ public:
         constexpr bool CanDo() const {
             return m_read_size > 0;
         }
+
+    private:
+        size_t m_read_size;
+        s32 m_skip_count;
+        bool m_done;
     };
 
 private:
     class NodeBuffer {
         YUZU_NON_COPYABLE(NodeBuffer);
 
-    private:
-        void* m_header;
-
     public:
         NodeBuffer() : m_header() {}
 
@@ -187,6 +184,9 @@ private:
             static_assert(sizeof(T) == sizeof(NodeHeader));
             return reinterpret_cast<T*>(m_header);
         }
+
+    private:
+        void* m_header;
     };
 
 private:
@@ -219,51 +219,6 @@ private:
     }
 
 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:
     BucketTree()
         : m_node_storage(), m_entry_storage(), m_node_l1(), m_node_size(), m_entry_size(),
           m_entry_count(), m_offset_count(), m_entry_set_count(), m_offset_cache() {}
@@ -299,6 +254,40 @@ public:
         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:
     template <typename EntryType>
     struct ContinuousReadingParam {
@@ -327,35 +316,23 @@ private:
     }
 
     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 {
     YUZU_NON_COPYABLE(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:
     constexpr Visitor()
         : 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 FindEntryWithBuffer(s64 virtual_address, s32 entry_set_index, char* buffer);
     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
diff --git a/src/core/file_sys/fssystem/fssystem_compressed_storage.h b/src/core/file_sys/fssystem/fssystem_compressed_storage.h
index e407add1b..33d93938e 100644
--- a/src/core/file_sys/fssystem/fssystem_compressed_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_compressed_storage.h
@@ -50,13 +50,6 @@ private:
         YUZU_NON_COPYABLE(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:
         CompressedStorageCore() : m_table(), m_data_storage() {}
 
@@ -296,7 +289,7 @@ private:
             ASSERT(offset >= 0);
             ASSERT(this->IsInitialized());
 
-            // Succeed immediately, if we hvae nothing to read.
+            // Succeed immediately, if we have nothing to read.
             R_SUCCEED_IF(size == 0);
 
             // Declare read lambda.
@@ -307,10 +300,13 @@ private:
                 u32 physical_size;
                 u32 virtual_size;
             };
-            Entries entries[EntriesCountMax];
+            std::array<Entries, EntriesCountMax> entries;
             s32 entry_count = 0;
             Entry prev_entry = {
                 .virt_offset = -1,
+                .phys_offset{},
+                .compression_type{},
+                .phys_size{},
             };
             bool will_allocate_pooled_buffer = false;
             s64 required_access_physical_offset = 0;
@@ -594,7 +590,7 @@ private:
                         }
                         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++] = {
                             .compression_type = entry.compression_type,
                             .gap_from_prev = static_cast<u32>(gap_from_prev),
@@ -621,7 +617,7 @@ private:
                                 .virtual_size = static_cast<u32>(read_size),
                             };
                         } 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 =
                                 read_func(static_cast<size_t>(read_size),
                                           [&](void* dst, size_t dst_size) -> Result {
@@ -668,6 +664,13 @@ private:
         bool IsInitialized() const {
             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 {
@@ -687,9 +690,6 @@ private:
         };
         static_assert(std::is_trivial_v<AccessRange>);
 
-    private:
-        s64 m_storage_size = 0;
-
     public:
         CacheManager() = default;
 
@@ -890,11 +890,10 @@ private:
 
             R_SUCCEED();
         }
-    };
 
-private:
-    mutable CompressedStorageCore m_core;
-    mutable CacheManager m_cache_manager;
+    private:
+        s64 m_storage_size = 0;
+    };
 
 public:
     CompressedStorage() = default;
@@ -955,6 +954,10 @@ public:
             return 0;
         }
     }
+
+private:
+    mutable CompressedStorageCore m_core;
+    mutable CacheManager m_cache_manager;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp b/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp
index 8734f84ca..ef552cefe 100644
--- a/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp
+++ b/src/core/file_sys/fssystem/fssystem_compression_configuration.cpp
@@ -9,7 +9,7 @@ namespace FileSys {
 namespace {
 
 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_SUCCEED();
 }
@@ -23,14 +23,14 @@ constexpr DecompressorFunction GetNcaDecompressorFunction(CompressionType type)
     }
 }
 
-constexpr NcaCompressionConfiguration g_nca_compression_configuration{
-    .get_decompressor = GetNcaDecompressorFunction,
-};
-
 } // namespace
 
-const NcaCompressionConfiguration* GetNcaCompressionConfiguration() {
-    return std::addressof(g_nca_compression_configuration);
+const NcaCompressionConfiguration& GetNcaCompressionConfiguration() {
+    static const NcaCompressionConfiguration configuration = {
+        .get_decompressor = GetNcaDecompressorFunction,
+    };
+
+    return configuration;
 }
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_compression_configuration.h b/src/core/file_sys/fssystem/fssystem_compression_configuration.h
index b4ec4f203..ec9b48e9a 100644
--- a/src/core/file_sys/fssystem/fssystem_compression_configuration.h
+++ b/src/core/file_sys/fssystem/fssystem_compression_configuration.h
@@ -7,6 +7,6 @@
 
 namespace FileSys {
 
-const NcaCompressionConfiguration* GetNcaCompressionConfiguration();
+const NcaCompressionConfiguration& GetNcaCompressionConfiguration();
 
 }
diff --git a/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp b/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp
index 7b89d4512..a4f0cde28 100644
--- a/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp
+++ b/src/core/file_sys/fssystem/fssystem_crypto_configuration.cpp
@@ -48,7 +48,15 @@ void GenerateKey(void* dst_key, size_t dst_key_size, const void* src_key, size_t
 
 const NcaCryptoConfiguration& GetCryptoConfiguration() {
     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,
+        .verify_sign1{},
+        .is_plaintext_header_available{},
+        .is_available_sw_key{},
     };
 
     return configuration;
diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h
index 3d216e4ae..5cf697efe 100644
--- a/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h
@@ -24,7 +24,7 @@ static_assert(alignof(HierarchicalIntegrityVerificationLevelInformation) == 0x4)
 
 struct HierarchicalIntegrityVerificationInformation {
     u32 max_layers;
-    HierarchicalIntegrityVerificationLevelInformation info[IntegrityMaxLayerCount - 1];
+    std::array<HierarchicalIntegrityVerificationLevelInformation, IntegrityMaxLayerCount - 1> info;
     HashSalt seed;
 
     s64 GetLayeredHashSize() const {
@@ -52,7 +52,7 @@ static_assert(std::is_trivial_v<HierarchicalIntegrityVerificationMetaInformation
 struct HierarchicalIntegrityVerificationSizeSet {
     s64 control_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>);
 
@@ -60,13 +60,6 @@ class HierarchicalIntegrityVerificationStorage : public IReadOnlyStorage {
     YUZU_NON_COPYABLE(HierarchicalIntegrityVerificationStorage);
     YUZU_NON_MOVEABLE(HierarchicalIntegrityVerificationStorage);
 
-private:
-    friend struct HierarchicalIntegrityVerificationMetaInformation;
-
-protected:
-    static constexpr s64 HashSize = 256 / 8;
-    static constexpr size_t MaxLayers = IntegrityMaxLayerCount;
-
 public:
     using GenerateRandomFunction = void (*)(void* dst, size_t size);
 
@@ -83,7 +76,7 @@ public:
         };
 
     private:
-        VirtualFile m_storages[DataStorage + 1];
+        std::array<VirtualFile, DataStorage + 1> m_storages;
 
     public:
         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:
     HierarchicalIntegrityVerificationStorage();
     virtual ~HierarchicalIntegrityVerificationStorage() override {
@@ -159,6 +139,26 @@ public:
     static constexpr s8 GetDefaultDataCacheBufferLevel(u32 max_layers) {
         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
diff --git a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h
index 717ba9748..18df400af 100644
--- a/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h
@@ -19,15 +19,6 @@ public:
     static constexpr s32 LayerCount = 3;
     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:
     HierarchicalSha256Storage() : m_mutex() {}
 
@@ -39,6 +30,15 @@ public:
     }
 
     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
diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp b/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp
index 45aa08d30..7544e70b2 100644
--- a/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp
+++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.cpp
@@ -72,7 +72,7 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
 
     auto cur_entry = *visitor.Get<Entry>();
     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 (count >= entry_count) {
                 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 {
     // Validate pre-conditions.
-    ASSERT(offset >= 0);
     ASSERT(this->IsInitialized());
     ASSERT(buffer != nullptr);
 
diff --git a/src/core/file_sys/fssystem/fssystem_indirect_storage.h b/src/core/file_sys/fssystem/fssystem_indirect_storage.h
index 39293667b..7854335bf 100644
--- a/src/core/file_sys/fssystem/fssystem_indirect_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_indirect_storage.h
@@ -21,27 +21,27 @@ public:
     static constexpr size_t NodeSize = 16_KiB;
 
     struct Entry {
-        u8 virt_offset[sizeof(s64)];
-        u8 phys_offset[sizeof(s64)];
+        std::array<u8, sizeof(s64)> virt_offset;
+        std::array<u8, sizeof(s64)> phys_offset;
         s32 storage_index;
 
         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 offset;
-            std::memcpy(std::addressof(offset), this->virt_offset, sizeof(s64));
+            std::memcpy(std::addressof(offset), this->virt_offset.data(), sizeof(s64));
             return offset;
         }
 
         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 offset;
-            std::memcpy(std::addressof(offset), this->phys_offset, sizeof(s64));
+            std::memcpy(std::addressof(offset), this->phys_offset.data(), sizeof(s64));
             return offset;
         }
     };
@@ -61,43 +61,6 @@ public:
     };
     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:
     IndirectStorage() : m_table(), m_data_storage() {}
     virtual ~IndirectStorage() {
@@ -131,7 +94,7 @@ public:
                         s64 size);
 
     virtual size_t GetSize() const override {
-        BucketTree::Offsets offsets;
+        BucketTree::Offsets offsets{};
         m_table.GetOffsets(std::addressof(offsets));
 
         return offsets.end_offset;
@@ -139,6 +102,19 @@ public:
 
     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:
     BucketTree& GetEntryTable() {
         return m_table;
@@ -151,6 +127,30 @@ protected:
 
     template <bool ContinuousCheck, bool RangeCheck, typename F>
     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>
diff --git a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h
index b80e9a302..5f8512b2a 100644
--- a/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_integrity_romfs_storage.h
@@ -13,11 +13,6 @@ constexpr inline size_t IntegrityLayerCountRomFs = 7;
 constexpr inline size_t IntegrityHashLayerBlockSize = 16_KiB;
 
 class IntegrityRomFsStorage : public IReadOnlyStorage {
-private:
-    HierarchicalIntegrityVerificationStorage m_integrity_storage;
-    Hash m_master_hash;
-    std::shared_ptr<ArrayVfsFile<sizeof(Hash)>> m_master_hash_storage;
-
 public:
     IntegrityRomFsStorage() {}
     virtual ~IntegrityRomFsStorage() override {
@@ -37,6 +32,11 @@ public:
     virtual size_t GetSize() const override {
         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
diff --git a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
index 0dba0c8d9..2f73abf86 100644
--- a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
+++ b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
@@ -8,7 +8,7 @@ namespace FileSys {
 
 constexpr inline u32 ILog2(u32 val) {
     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,
diff --git a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h
index 08515a268..09f76799d 100644
--- a/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_integrity_verification_storage.h
@@ -18,19 +18,10 @@ public:
     static constexpr s64 HashSize = 256 / 8;
 
     struct BlockHash {
-        u8 hash[HashSize];
+        std::array<u8, HashSize> hash;
     };
     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:
     IntegrityVerificationStorage()
         : m_verification_block_size(0), m_verification_block_order(0),
@@ -60,6 +51,15 @@ private:
         ASSERT(hash != nullptr);
         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
diff --git a/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h b/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h
index 7637272d5..c07a127fb 100644
--- a/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
 #pragma once
 
 #include "core/file_sys/fssystem/fs_i_storage.h"
@@ -8,11 +11,6 @@ class MemoryResourceBufferHoldStorage : public IStorage {
     YUZU_NON_COPYABLE(MemoryResourceBufferHoldStorage);
     YUZU_NON_MOVEABLE(MemoryResourceBufferHoldStorage);
 
-private:
-    VirtualFile m_storage;
-    void* m_buffer;
-    size_t m_buffer_size;
-
 public:
     MemoryResourceBufferHoldStorage(VirtualFile storage, size_t 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);
     }
+
+private:
+    VirtualFile m_storage;
+    void* m_buffer;
+    size_t m_buffer_size;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp
index 450135ae0..0f5432203 100644
--- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp
+++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp
@@ -228,7 +228,7 @@ Result NcaFileSystemDriver::OpenStorageImpl(VirtualFile* out, NcaFsHeaderReader*
 
     // Process indirect layer.
     if (patch_info.HasIndirectTable()) {
-        // Create the indirect meta storage
+        // Create the indirect meta storage.
         VirtualFile indirect_storage_meta_storage = patch_meta_indirect_meta_storage;
         if (indirect_storage_meta_storage == nullptr) {
             // If we don't have a meta storage, we must not have a patch meta hash layer.
diff --git a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h
index d317b35ac..5771a21fc 100644
--- a/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h
+++ b/src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h
@@ -37,11 +37,13 @@ struct NcaCryptoConfiguration {
 
     static constexpr size_t KeyGenerationMax = 32;
 
-    const u8* header_1_sign_key_moduli[Header1SignatureKeyGenerationMax + 1];
-    u8 header_1_sign_key_public_exponent[Rsa2048KeyPublicExponentSize];
-    u8 key_area_encryption_key_source[KeyAreaEncryptionKeyIndexCount][Aes128KeySize];
-    u8 header_encryption_key_source[Aes128KeySize];
-    u8 header_encrypted_encryption_keys[HeaderEncryptionKeyCount][Aes128KeySize];
+    std::array<const u8*, Header1SignatureKeyGenerationMax + 1> header_1_sign_key_moduli;
+    std::array<u8, Rsa2048KeyPublicExponentSize> header_1_sign_key_public_exponent;
+    std::array<std::array<u8, Aes128KeySize>, KeyAreaEncryptionKeyIndexCount>
+        key_area_encryption_key_source;
+    std::array<u8, Aes128KeySize> header_encryption_key_source;
+    std::array<std::array<u8, Aes128KeySize>, HeaderEncryptionKeyCount>
+        header_encrypted_encryption_keys;
     KeyGenerationFunction generate_key;
     VerifySign1Function verify_sign1;
     bool is_plaintext_header_available;
@@ -89,18 +91,6 @@ class NcaReader {
     YUZU_NON_COPYABLE(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:
     NcaReader();
     ~NcaReader();
@@ -147,16 +137,26 @@ public:
     bool GetHeaderSign1Valid() 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 {
     YUZU_NON_COPYABLE(NcaFsHeaderReader);
     YUZU_NON_MOVEABLE(NcaFsHeaderReader);
 
-private:
-    NcaFsHeader m_data;
-    s32 m_fs_index;
-
 public:
     NcaFsHeaderReader() : m_fs_index(-1) {
         std::memset(std::addressof(m_data), 0, sizeof(m_data));
@@ -200,6 +200,10 @@ public:
     NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo();
     const NcaMetaDataHashDataInfo& GetSparseMetaDataHashDataInfo() const;
     NcaFsHeader::MetaDataHashType GetSparseMetaHashType() const;
+
+private:
+    NcaFsHeader m_data;
+    s32 m_fs_index;
 };
 
 class NcaFileSystemDriver {
@@ -236,10 +240,6 @@ private:
         None = 1,
     };
 
-private:
-    std::shared_ptr<NcaReader> m_original_reader;
-    std::shared_ptr<NcaReader> m_reader;
-
 public:
     static Result SetupFsHeaderReader(NcaFsHeaderReader* out, const NcaReader& reader,
                                       s32 fs_index);
@@ -355,6 +355,10 @@ public:
                                    VirtualFile* out_meta, VirtualFile base_storage,
                                    const NcaCompressionInfo& compression_info,
                                    GetDecompressorFunction get_decompressor);
+
+private:
+    std::shared_ptr<NcaReader> m_original_reader;
+    std::shared_ptr<NcaReader> m_reader;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp
index cd4c49069..a3714ab37 100644
--- a/src/core/file_sys/fssystem/fssystem_nca_reader.cpp
+++ b/src/core/file_sys/fssystem/fssystem_nca_reader.cpp
@@ -53,24 +53,27 @@ Result NcaReader::Initialize(VirtualFile base_storage, const NcaCryptoConfigurat
     // Generate keys for header.
     using AesXtsStorageForNcaHeader = AesXtsStorage;
 
-    constexpr const s32 HeaderKeyTypeValues[NcaCryptoConfiguration::HeaderEncryptionKeyCount] = {
-        static_cast<s32>(KeyType::NcaHeaderKey1),
-        static_cast<s32>(KeyType::NcaHeaderKey2),
-    };
-
-    u8 header_decryption_keys[NcaCryptoConfiguration::HeaderEncryptionKeyCount]
-                             [NcaCryptoConfiguration::Aes128KeySize];
+    constexpr std::array<s32, NcaCryptoConfiguration::HeaderEncryptionKeyCount>
+        HeaderKeyTypeValues = {
+            static_cast<s32>(KeyType::NcaHeaderKey1),
+            static_cast<s32>(KeyType::NcaHeaderKey2),
+        };
+
+    std::array<std::array<u8, NcaCryptoConfiguration::Aes128KeySize>,
+               NcaCryptoConfiguration::HeaderEncryptionKeyCount>
+        header_decryption_keys;
     for (size_t i = 0; i < NcaCryptoConfiguration::HeaderEncryptionKeyCount; i++) {
-        crypto_cfg.generate_key(header_decryption_keys[i], AesXtsStorageForNcaHeader::KeySize,
-                                crypto_cfg.header_encrypted_encryption_keys[i],
+        crypto_cfg.generate_key(header_decryption_keys[i].data(),
+                                AesXtsStorageForNcaHeader::KeySize,
+                                crypto_cfg.header_encrypted_encryption_keys[i].data(),
                                 AesXtsStorageForNcaHeader::KeySize, HeaderKeyTypeValues[i]);
     }
 
     // Create the header storage.
-    const u8 header_iv[AesXtsStorageForNcaHeader::IvSize] = {};
+    std::array<u8, AesXtsStorageForNcaHeader::IvSize> header_iv = {};
     work_header_storage = std::make_unique<AesXtsStorageForNcaHeader>(
-        base_storage, header_decryption_keys[0], header_decryption_keys[1],
-        AesXtsStorageForNcaHeader::KeySize, header_iv, AesXtsStorageForNcaHeader::IvSize,
+        base_storage, header_decryption_keys[0].data(), header_decryption_keys[1].data(),
+        AesXtsStorageForNcaHeader::KeySize, header_iv.data(), AesXtsStorageForNcaHeader::IvSize,
         NcaHeader::XtsBlockSize);
 
     // 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;
     }
 
-    // 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.
     if (crypto_cfg.verify_sign1 != nullptr) {
         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 we don't, then we don't have an external key, so we need to generate decryption keys.
         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,
             Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
         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,
             Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
         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,
             Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
         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,
             Aes128KeySize, GetKeyTypeValue(m_header.key_index, m_header.GetProperKeyGeneration()));
 
         // 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() +
                         NcaHeader::DecryptionKey_AesCtrHw * Aes128KeySize,
                     Aes128KeySize);
     }
 
     // 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.
     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 {
     ASSERT(m_body_storage != nullptr);
     ASSERT(0 <= index && index < NcaHeader::DecryptionKey_Count);
-    return m_decryption_keys[index];
+    return m_decryption_keys[index].data();
 }
 
 bool NcaReader::HasValidInternalKey() const {
@@ -339,14 +328,14 @@ bool NcaReader::HasExternalDecryptionKey() 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) {
     ASSERT(src != nullptr);
     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 {
diff --git a/src/core/file_sys/fssystem/fssystem_pooled_buffer.h b/src/core/file_sys/fssystem/fssystem_pooled_buffer.h
index 1df3153a1..9a6adbcb5 100644
--- a/src/core/file_sys/fssystem/fssystem_pooled_buffer.h
+++ b/src/core/file_sys/fssystem/fssystem_pooled_buffer.h
@@ -18,27 +18,6 @@ constexpr inline size_t BufferPoolWorkSize = 320;
 class 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:
     // Constructor/Destructor.
     constexpr PooledBuffer() : m_buffer(), m_size() {}
@@ -89,8 +68,28 @@ public:
         return m_size;
     }
 
+public:
+    static size_t GetAllocatableSizeMax() {
+        return GetAllocatableSizeMaxCore(false);
+    }
+    static size_t GetAllocatableParticularlyLargeSizeMax() {
+        return GetAllocatableSizeMaxCore(true);
+    }
+
+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);
+
+private:
+    char* m_buffer;
+    size_t m_size;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp b/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp
index 05e8820f7..8574a11dd 100644
--- a/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp
+++ b/src/core/file_sys/fssystem/fssystem_sparse_storage.cpp
@@ -7,7 +7,6 @@ namespace FileSys {
 
 size_t SparseStorage::Read(u8* buffer, size_t size, size_t offset) const {
     // Validate preconditions.
-    ASSERT(offset >= 0);
     ASSERT(this->IsInitialized());
     ASSERT(buffer != nullptr);
 
diff --git a/src/core/file_sys/fssystem/fssystem_sparse_storage.h b/src/core/file_sys/fssystem/fssystem_sparse_storage.h
index c1ade7195..6c196ec61 100644
--- a/src/core/file_sys/fssystem/fssystem_sparse_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_sparse_storage.h
@@ -22,7 +22,6 @@ private:
         }
 
         virtual size_t Read(u8* buffer, size_t size, size_t offset) const override {
-            ASSERT(offset >= 0);
             ASSERT(buffer != nullptr || size == 0);
 
             if (size > 0) {
@@ -33,9 +32,6 @@ private:
         }
     };
 
-private:
-    VirtualFile m_zero_storage;
-
 public:
     SparseStorage() : IndirectStorage(), m_zero_storage(std::make_shared<ZeroStorage>()) {}
     virtual ~SparseStorage() {}
@@ -68,6 +64,9 @@ private:
     void SetZeroStorage() {
         return this->SetStorage(1, m_zero_storage, 0, std::numeric_limits<s64>::max());
     }
+
+private:
+    VirtualFile m_zero_storage;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_switch_storage.h b/src/core/file_sys/fssystem/fssystem_switch_storage.h
index 140f21ab7..2b43927cb 100644
--- a/src/core/file_sys/fssystem/fssystem_switch_storage.h
+++ b/src/core/file_sys/fssystem/fssystem_switch_storage.h
@@ -17,11 +17,6 @@ public:
         s64 size;
     };
 
-private:
-    VirtualFile m_inside_region_storage;
-    VirtualFile m_outside_region_storage;
-    Region m_region;
-
 public:
     RegionSwitchStorage(VirtualFile&& i, VirtualFile&& o, Region r)
         : m_inside_region_storage(std::move(i)), m_outside_region_storage(std::move(o)),
@@ -75,6 +70,11 @@ private:
             return false;
         }
     }
+
+private:
+    VirtualFile m_inside_region_storage;
+    VirtualFile m_outside_region_storage;
+    Region m_region;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/fssystem/fssystem_utility.cpp b/src/core/file_sys/fssystem/fssystem_utility.cpp
index 4dddfd75a..ceabb8ff1 100644
--- a/src/core/file_sys/fssystem/fssystem_utility.cpp
+++ b/src/core/file_sys/fssystem/fssystem_utility.cpp
@@ -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"
 
 namespace FileSys {
diff --git a/src/core/file_sys/submission_package.cpp b/src/core/file_sys/submission_package.cpp
index aa41c7c31..73582ad50 100644
--- a/src/core/file_sys/submission_package.cpp
+++ b/src/core/file_sys/submission_package.cpp
@@ -19,9 +19,9 @@
 namespace FileSys {
 
 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_),
-      status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)),
-      keys{Core::Crypto::KeyManager::Instance()} {
+    : file(std::move(file_)), expected_program_id(title_id_),
+      program_index(program_index_), status{Loader::ResultStatus::Success},
+      pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
     if (pfs->GetStatus() != Loader::ResultStatus::Success) {
         status = pfs->GetStatus();
         return;