From 67a45c97ef3024dee2f6954455af6fdcff13aa78 Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Sat, 9 Oct 2021 15:40:06 -0700 Subject: [PATCH] exo/vapours: refactor member variables to m_ over this-> --- .../source/secmon_loader_uncompress.cpp | 32 ++-- .../source/fatal_device_page_table.cpp | 8 +- .../mariko_fatal/source/fs/fatal_fs_api.hpp | 10 +- .../program/source/secmon_page_mapper.cpp | 6 +- .../program/source/secmon_page_mapper.hpp | 12 +- .../program/source/smc/secmon_smc_rsa.cpp | 24 +-- .../source/fusee_loader_uncompress.cpp | 34 ++-- fusee/program/source/fs/fusee_fs_api.hpp | 10 +- fusee/program/source/fusee_uncompress.cpp | 32 ++-- .../exosphere/secmon/secmon_memory_layout.hpp | 73 +++---- .../crypto_aes_impl_security_engine.cpp | 14 +- .../crypto_aes_ctr_encryptor_decryptor.hpp | 12 +- .../vapours/crypto/crypto_aes_decryptor.hpp | 8 +- .../vapours/crypto/crypto_aes_encryptor.hpp | 8 +- .../crypto/crypto_aes_gcm_encryptor.hpp | 16 +- .../crypto_aes_xts_encryptor_decryptor.hpp | 16 +- .../vapours/crypto/crypto_ctr_decryptor.hpp | 10 +- .../vapours/crypto/crypto_ctr_encryptor.hpp | 10 +- .../vapours/crypto/crypto_gcm_encryptor.hpp | 14 +- .../vapours/crypto/crypto_hmac_generator.hpp | 8 +- .../vapours/crypto/crypto_rsa_calculator.hpp | 12 +- .../crypto/crypto_rsa_oaep_decryptor.hpp | 60 +++--- .../crypto/crypto_rsa_oaep_encryptor.hpp | 58 +++--- .../crypto/crypto_rsa_pss_verifier.hpp | 44 ++--- .../vapours/crypto/crypto_sha1_generator.hpp | 8 +- .../crypto/crypto_sha256_generator.hpp | 16 +- .../vapours/crypto/crypto_xts_decryptor.hpp | 8 +- .../vapours/crypto/crypto_xts_encryptor.hpp | 8 +- .../vapours/crypto/impl/crypto_aes_impl.hpp | 6 +- .../vapours/crypto/impl/crypto_bignum.hpp | 64 +++---- .../crypto/impl/crypto_ctr_mode_impl.hpp | 52 ++--- .../crypto/impl/crypto_gcm_mode_impl.hpp | 32 ++-- .../vapours/crypto/impl/crypto_hmac_impl.hpp | 60 +++--- .../vapours/crypto/impl/crypto_sha1_impl.hpp | 4 +- .../crypto/impl/crypto_sha256_impl.hpp | 8 +- .../crypto/impl/crypto_xts_mode_impl.hpp | 32 ++-- .../include/vapours/device_code.hpp | 6 +- .../include/vapours/freebsd/tree.hpp | 42 ++--- .../libvapours/include/vapours/timespan.hpp | 60 +++--- .../vapours/util/util_aligned_buffer.hpp | 4 +- .../include/vapours/util/util_bitflagset.hpp | 18 +- .../include/vapours/util/util_bitset.hpp | 14 +- .../include/vapours/util/util_bitutil.hpp | 14 +- .../include/vapours/util/util_bounded_map.hpp | 40 ++-- .../include/vapours/util/util_fixed_tree.hpp | 34 ++-- .../vapours/util/util_intrusive_list.hpp | 178 +++++++++--------- .../include/vapours/util/util_tinymt.hpp | 66 +++---- .../impl/crypto_aes_impl.arch.arm64.cpp | 36 ++-- .../source/crypto/impl/crypto_bignum.cpp | 22 +-- .../impl/crypto_ctr_mode_impl.arch.arm64.cpp | 18 +- .../impl/crypto_gcm_mode_impl.arch.arm64.cpp | 98 +++++----- .../impl/crypto_sha1_impl.arch.arm64.cpp | 12 +- .../impl/crypto_sha256_impl.arch.arm64.cpp | 32 ++-- .../impl/crypto_xts_mode_impl.arch.arm64.cpp | 100 +++++----- .../crypto/impl/crypto_xts_mode_impl.cpp | 70 +++---- 55 files changed, 846 insertions(+), 847 deletions(-) diff --git a/exosphere/loader_stub/source/secmon_loader_uncompress.cpp b/exosphere/loader_stub/source/secmon_loader_uncompress.cpp index c4e3068aa..6791d2dd2 100644 --- a/exosphere/loader_stub/source/secmon_loader_uncompress.cpp +++ b/exosphere/loader_stub/source/secmon_loader_uncompress.cpp @@ -22,14 +22,14 @@ namespace ams::secmon::loader { class Lz4Uncompressor { private: - const u8 *src; - size_t src_size; - size_t src_offset; - u8 *dst; - size_t dst_size; - size_t dst_offset; + const u8 *m_src; + size_t m_src_size; + size_t m_src_offset; + u8 *m_dst; + size_t m_dst_size; + size_t m_dst_offset; public: - Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : src(static_cast(src)), src_size(src_size), src_offset(0), dst(static_cast(dst)), dst_size(dst_size), dst_offset(0) { + Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : m_src(static_cast(src)), m_src_size(src_size), m_src_offset(0), m_dst(static_cast(dst)), m_dst_size(dst_size), m_dst_offset(0) { /* ... */ } @@ -42,7 +42,7 @@ namespace ams::secmon::loader { this->Copy(this->GetCopySize(control >> 4)); /* If we've exceeded size, we're done. */ - if (this->src_offset >= this->src_size) { + if (m_src_offset >= m_src_size) { break; } @@ -55,21 +55,21 @@ namespace ams::secmon::loader { const size_t wide_copy_size = this->GetCopySize(control & 0xF); /* Copy bytes. */ - const size_t end_offset = this->dst_offset + wide_copy_size + 4; - for (size_t cur_offset = this->dst_offset; cur_offset < end_offset; this->dst_offset = (++cur_offset)) { + const size_t end_offset = m_dst_offset + wide_copy_size + 4; + for (size_t cur_offset = m_dst_offset; cur_offset < end_offset; m_dst_offset = (++cur_offset)) { AMS_ABORT_UNLESS(wide_offset <= cur_offset); - this->dst[cur_offset] = this->dst[cur_offset - wide_offset]; + m_dst[cur_offset] = m_dst[cur_offset - wide_offset]; } } } private: u8 ReadByte() { - return this->src[this->src_offset++]; + return m_src[m_src_offset++]; } bool CanRead() const { - return this->src_offset < this->src_size; + return m_src_offset < m_src_size; } size_t GetCopySize(u8 control) { @@ -87,9 +87,9 @@ namespace ams::secmon::loader { } void Copy(size_t size) { - __builtin_memcpy(this->dst + this->dst_offset, this->src + this->src_offset, size); - this->dst_offset += size; - this->src_offset += size; + __builtin_memcpy(m_dst + m_dst_offset, m_src + m_src_offset, size); + m_dst_offset += size; + m_src_offset += size; } }; diff --git a/exosphere/mariko_fatal/source/fatal_device_page_table.cpp b/exosphere/mariko_fatal/source/fatal_device_page_table.cpp index a4210d84a..7b3d5494f 100644 --- a/exosphere/mariko_fatal/source/fatal_device_page_table.cpp +++ b/exosphere/mariko_fatal/source/fatal_device_page_table.cpp @@ -76,10 +76,10 @@ namespace ams::secmon::fatal { Bit_Readable = 31, }; private: - u32 value; + u32 m_value; protected: constexpr ALWAYS_INLINE u32 SelectBit(Bit n) const { - return (this->value & (1u << n)); + return (m_value & (1u << n)); } constexpr ALWAYS_INLINE bool GetBit(Bit n) const { @@ -97,7 +97,7 @@ namespace ams::secmon::fatal { ALWAYS_INLINE void SetValue(u32 v) { /* Prevent re-ordering around entry modifications. */ __asm__ __volatile__("" ::: "memory"); - this->value = v; + m_value = v; __asm__ __volatile__("" ::: "memory"); } public: @@ -112,7 +112,7 @@ namespace ams::secmon::fatal { constexpr ALWAYS_INLINE u32 GetAttributes() const { return this->SelectBit(Bit_NonSecure) | this->SelectBit(Bit_Writeable) | this->SelectBit(Bit_Readable); } - constexpr ALWAYS_INLINE dd::PhysicalAddress GetPhysicalAddress() const { return (static_cast(this->value) << DevicePageBits) & PhysicalAddressMask; } + constexpr ALWAYS_INLINE dd::PhysicalAddress GetPhysicalAddress() const { return (static_cast(m_value) << DevicePageBits) & PhysicalAddressMask; } ALWAYS_INLINE void Invalidate() { this->SetValue(0); } }; diff --git a/exosphere/mariko_fatal/source/fs/fatal_fs_api.hpp b/exosphere/mariko_fatal/source/fs/fatal_fs_api.hpp index 6b32d0130..509ecbb06 100644 --- a/exosphere/mariko_fatal/source/fs/fatal_fs_api.hpp +++ b/exosphere/mariko_fatal/source/fs/fatal_fs_api.hpp @@ -28,7 +28,7 @@ namespace ams::fs { }; struct ReadOption { - u32 value; + u32 _value; static const ReadOption None; }; @@ -36,7 +36,7 @@ namespace ams::fs { inline constexpr const ReadOption ReadOption::None = {0}; inline constexpr bool operator==(const ReadOption &lhs, const ReadOption &rhs) { - return lhs.value == rhs.value; + return lhs._value == rhs._value; } inline constexpr bool operator!=(const ReadOption &lhs, const ReadOption &rhs) { @@ -46,10 +46,10 @@ namespace ams::fs { static_assert(util::is_pod::value && sizeof(ReadOption) == sizeof(u32)); struct WriteOption { - u32 value; + u32 _value; constexpr inline bool HasFlushFlag() const { - return this->value & 1; + return _value & 1; } static const WriteOption None; @@ -60,7 +60,7 @@ namespace ams::fs { inline constexpr const WriteOption WriteOption::Flush = {1}; inline constexpr bool operator==(const WriteOption &lhs, const WriteOption &rhs) { - return lhs.value == rhs.value; + return lhs._value == rhs._value; } inline constexpr bool operator!=(const WriteOption &lhs, const WriteOption &rhs) { diff --git a/exosphere/program/source/secmon_page_mapper.cpp b/exosphere/program/source/secmon_page_mapper.cpp index 355281ee1..014166316 100644 --- a/exosphere/program/source/secmon_page_mapper.cpp +++ b/exosphere/program/source/secmon_page_mapper.cpp @@ -23,16 +23,16 @@ namespace ams::secmon { void *PageMapperImpl::GetPointerTo(uintptr_t phys, size_t size) const { /* Ensure we stay within the page. */ - if (util::AlignDown(phys, 4_KB) != this->physical_address) { + if (util::AlignDown(phys, 4_KB) != m_physical_address) { return nullptr; } if (size != 0) { - if (util::AlignDown(phys + size - 1, 4_KB) != this->physical_address) { + if (util::AlignDown(phys + size - 1, 4_KB) != m_physical_address) { return nullptr; } } - return reinterpret_cast(phys + (this->virtual_address - this->physical_address)); + return reinterpret_cast(phys + (m_virtual_address - m_physical_address)); } bool PageMapperImpl::CopyToMapping(uintptr_t dst_phys, const void *src, size_t size) const { diff --git a/exosphere/program/source/secmon_page_mapper.hpp b/exosphere/program/source/secmon_page_mapper.hpp index a8745770f..7373fa5e0 100644 --- a/exosphere/program/source/secmon_page_mapper.hpp +++ b/exosphere/program/source/secmon_page_mapper.hpp @@ -22,10 +22,10 @@ namespace ams::secmon { class PageMapperImpl { private: - uintptr_t physical_address; - uintptr_t virtual_address; + uintptr_t m_physical_address; + uintptr_t m_virtual_address; public: - constexpr PageMapperImpl(uintptr_t phys) : physical_address(util::AlignDown(phys, 4_KB)), virtual_address() { /* ... */ } + constexpr PageMapperImpl(uintptr_t phys) : m_physical_address(util::AlignDown(phys, 4_KB)), m_virtual_address() { /* ... */ } void *GetPointerTo(uintptr_t phys, size_t size) const; @@ -37,14 +37,14 @@ namespace ams::secmon { template bool MapImpl() { - this->virtual_address = F(this->physical_address); - return this->virtual_address != 0; + m_virtual_address = F(m_physical_address); + return m_virtual_address != 0; } template void UnmapImpl() { F(); - this->virtual_address = 0; + m_virtual_address = 0; } }; diff --git a/exosphere/program/source/smc/secmon_smc_rsa.cpp b/exosphere/program/source/smc/secmon_smc_rsa.cpp index a797bd983..34982bb8a 100644 --- a/exosphere/program/source/smc/secmon_smc_rsa.cpp +++ b/exosphere/program/source/smc/secmon_smc_rsa.cpp @@ -55,31 +55,31 @@ namespace ams::secmon::smc { class PrepareEsDeviceUniqueKeyAsyncArguments { private: - int generation; - EsCommonKeyType type; - u8 label_digest[crypto::Sha256Generator::HashSize]; + int m_generation; + EsCommonKeyType m_type; + u8 m_label_digest[crypto::Sha256Generator::HashSize]; public: void Set(int gen, EsCommonKeyType t, const u8 ld[crypto::Sha256Generator::HashSize]) { - this->generation = gen; - this->type = t; - std::memcpy(this->label_digest, ld, sizeof(this->label_digest)); + m_generation = gen; + m_type = t; + std::memcpy(m_label_digest, ld, sizeof(m_label_digest)); } - int GetKeyGeneration() const { return this->generation; } - EsCommonKeyType GetCommonKeyType() const { return this->type; } - void GetLabelDigest(u8 dst[crypto::Sha256Generator::HashSize]) const { std::memcpy(dst, this->label_digest, sizeof(this->label_digest)); } + int GetKeyGeneration() const { return m_generation; } + EsCommonKeyType GetCommonKeyType() const { return m_type; } + void GetLabelDigest(u8 dst[crypto::Sha256Generator::HashSize]) const { std::memcpy(dst, m_label_digest, sizeof(m_label_digest)); } }; class ModularExponentiateByStorageKeyAsyncArguments { private: - u8 msg[se::RsaSize]; + u8 m_msg[se::RsaSize]; public: void Set(const void *m, size_t m_size) { AMS_UNUSED(m_size); - std::memcpy(this->msg, m, sizeof(this->msg)); + std::memcpy(m_msg, m, sizeof(m_msg)); } - const u8 *GetMessage() const { return this->msg; } + const u8 *GetMessage() const { return m_msg; } }; constinit SmcResult g_exp_mod_result = SmcResult::Success; diff --git a/fusee/loader_stub/source/fusee_loader_uncompress.cpp b/fusee/loader_stub/source/fusee_loader_uncompress.cpp index 77d4de544..ace64588f 100644 --- a/fusee/loader_stub/source/fusee_loader_uncompress.cpp +++ b/fusee/loader_stub/source/fusee_loader_uncompress.cpp @@ -22,14 +22,14 @@ namespace ams::nxboot::loader { class Lz4Uncompressor { private: - const u8 *src; - size_t src_size; - size_t src_offset; - u8 *dst; - size_t dst_size; - size_t dst_offset; + const u8 *m_src; + size_t m_src_size; + size_t m_src_offset; + u8 *m_dst; + size_t m_dst_size; + size_t m_dst_offset; public: - Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : src(static_cast(src)), src_size(src_size), src_offset(0), dst(static_cast(dst)), dst_size(dst_size), dst_offset(0) { + Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : m_src(static_cast(src)), m_src_size(src_size), m_src_offset(0), m_dst(static_cast(dst)), m_dst_size(dst_size), m_dst_offset(0) { /* ... */ } @@ -42,7 +42,7 @@ namespace ams::nxboot::loader { this->Copy(this->GetCopySize(control >> 4)); /* If we've exceeded size, we're done. */ - if (this->src_offset >= this->src_size) { + if (m_src_offset >= m_src_size) { break; } @@ -55,21 +55,21 @@ namespace ams::nxboot::loader { const size_t wide_copy_size = this->GetCopySize(control & 0xF); /* Copy bytes. */ - const size_t end_offset = this->dst_offset + wide_copy_size + 4; - for (size_t cur_offset = this->dst_offset; cur_offset < end_offset; this->dst_offset = (++cur_offset)) { + const size_t end_offset = m_dst_offset + wide_copy_size + 4; + for (size_t cur_offset = m_dst_offset; cur_offset < end_offset; m_dst_offset = (++cur_offset)) { AMS_ABORT_UNLESS(wide_offset <= cur_offset); - this->dst[cur_offset] = this->dst[cur_offset - wide_offset]; + m_dst[cur_offset] = m_dst[cur_offset - wide_offset]; } } } private: u8 ReadByte() { - return this->src[this->src_offset++]; + return m_src[m_src_offset++]; } bool CanRead() const { - return this->src_offset < this->src_size; + return m_src_offset < m_src_size; } size_t GetCopySize(u8 control) { @@ -87,11 +87,9 @@ namespace ams::nxboot::loader { } void Copy(size_t size) { - for (size_t i = 0; i < size; ++i) { - this->dst[this->dst_offset + i] = this->src[this->src_offset + i]; - } - this->dst_offset += size; - this->src_offset += size; + __builtin_memcpy(m_dst + m_dst_offset, m_src + m_src_offset, size); + m_dst_offset += size; + m_src_offset += size; } }; diff --git a/fusee/program/source/fs/fusee_fs_api.hpp b/fusee/program/source/fs/fusee_fs_api.hpp index 86bae16c7..5aa0ae763 100644 --- a/fusee/program/source/fs/fusee_fs_api.hpp +++ b/fusee/program/source/fs/fusee_fs_api.hpp @@ -28,7 +28,7 @@ namespace ams::fs { }; struct ReadOption { - u32 value; + u32 _value; static const ReadOption None; }; @@ -36,7 +36,7 @@ namespace ams::fs { inline constexpr const ReadOption ReadOption::None = {0}; inline constexpr bool operator==(const ReadOption &lhs, const ReadOption &rhs) { - return lhs.value == rhs.value; + return lhs._value == rhs._value; } inline constexpr bool operator!=(const ReadOption &lhs, const ReadOption &rhs) { @@ -46,10 +46,10 @@ namespace ams::fs { static_assert(util::is_pod::value && sizeof(ReadOption) == sizeof(u32)); struct WriteOption { - u32 value; + u32 _value; constexpr inline bool HasFlushFlag() const { - return this->value & 1; + return _value & 1; } static const WriteOption None; @@ -60,7 +60,7 @@ namespace ams::fs { inline constexpr const WriteOption WriteOption::Flush = {1}; inline constexpr bool operator==(const WriteOption &lhs, const WriteOption &rhs) { - return lhs.value == rhs.value; + return lhs._value == rhs._value; } inline constexpr bool operator!=(const WriteOption &lhs, const WriteOption &rhs) { diff --git a/fusee/program/source/fusee_uncompress.cpp b/fusee/program/source/fusee_uncompress.cpp index a48fd8b6a..aec5f7f2c 100644 --- a/fusee/program/source/fusee_uncompress.cpp +++ b/fusee/program/source/fusee_uncompress.cpp @@ -22,14 +22,14 @@ namespace ams::nxboot { class Lz4Uncompressor { private: - const u8 *src; - size_t src_size; - size_t src_offset; - u8 *dst; - size_t dst_size; - size_t dst_offset; + const u8 *m_src; + size_t m_src_size; + size_t m_src_offset; + u8 *m_dst; + size_t m_dst_size; + size_t m_dst_offset; public: - Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : src(static_cast(src)), src_size(src_size), src_offset(0), dst(static_cast(dst)), dst_size(dst_size), dst_offset(0) { + Lz4Uncompressor(void *dst, size_t dst_size, const void *src, size_t src_size) : m_src(static_cast(src)), m_src_size(src_size), m_src_offset(0), m_dst(static_cast(dst)), m_dst_size(dst_size), m_dst_offset(0) { /* ... */ } @@ -42,7 +42,7 @@ namespace ams::nxboot { this->Copy(this->GetCopySize(control >> 4)); /* If we've exceeded size, we're done. */ - if (this->src_offset >= this->src_size) { + if (m_src_offset >= m_src_size) { break; } @@ -55,21 +55,21 @@ namespace ams::nxboot { const size_t wide_copy_size = this->GetCopySize(control & 0xF); /* Copy bytes. */ - const size_t end_offset = this->dst_offset + wide_copy_size + 4; - for (size_t cur_offset = this->dst_offset; cur_offset < end_offset; this->dst_offset = (++cur_offset)) { + const size_t end_offset = m_dst_offset + wide_copy_size + 4; + for (size_t cur_offset = m_dst_offset; cur_offset < end_offset; m_dst_offset = (++cur_offset)) { AMS_ABORT_UNLESS(wide_offset <= cur_offset); - this->dst[cur_offset] = this->dst[cur_offset - wide_offset]; + m_dst[cur_offset] = m_dst[cur_offset - wide_offset]; } } } private: u8 ReadByte() { - return this->src[this->src_offset++]; + return m_src[m_src_offset++]; } bool CanRead() const { - return this->src_offset < this->src_size; + return m_src_offset < m_src_size; } size_t GetCopySize(u8 control) { @@ -87,9 +87,9 @@ namespace ams::nxboot { } void Copy(size_t size) { - __builtin_memcpy(this->dst + this->dst_offset, this->src + this->src_offset, size); - this->dst_offset += size; - this->src_offset += size; + __builtin_memcpy(m_dst + m_dst_offset, m_src + m_src_offset, size); + m_dst_offset += size; + m_src_offset += size; } }; diff --git a/libraries/libexosphere/include/exosphere/secmon/secmon_memory_layout.hpp b/libraries/libexosphere/include/exosphere/secmon/secmon_memory_layout.hpp index 9ec2ccd15..1ea124d87 100644 --- a/libraries/libexosphere/include/exosphere/secmon/secmon_memory_layout.hpp +++ b/libraries/libexosphere/include/exosphere/secmon/secmon_memory_layout.hpp @@ -22,52 +22,53 @@ namespace ams::secmon { using Address = u64; struct MemoryRegion { - Address start_address; - Address end_address; - - constexpr MemoryRegion(Address address, size_t size) : start_address(address), end_address(address + size) { - if (end_address < start_address) { - __builtin_unreachable(); + private: + Address m_start_address; + Address m_end_address; + public: + consteval MemoryRegion(Address address, size_t size) : m_start_address(address), m_end_address(address + size) { + if (m_end_address < m_start_address) { + __builtin_unreachable(); + } } - } - constexpr Address GetStartAddress() const { - return this->start_address; - } + constexpr Address GetStartAddress() const { + return m_start_address; + } - constexpr Address GetAddress() const { - return this->GetStartAddress(); - } + constexpr Address GetAddress() const { + return this->GetStartAddress(); + } - constexpr Address GetEndAddress() const { - return this->end_address; - } + constexpr Address GetEndAddress() const { + return m_end_address; + } - constexpr Address GetLastAddress() const { - return this->end_address - 1; - } + constexpr Address GetLastAddress() const { + return m_end_address - 1; + } - constexpr size_t GetSize() const { - return this->end_address - this->start_address; - } + constexpr size_t GetSize() const { + return m_end_address - m_start_address; + } - constexpr bool Contains(Address address, size_t size) const { - return this->start_address <= address && (address + size - 1) <= this->GetLastAddress(); - } + constexpr bool Contains(Address address, size_t size) const { + return m_start_address <= address && (address + size - 1) <= this->GetLastAddress(); + } - constexpr bool Contains(const MemoryRegion &rhs) const { - return this->Contains(rhs.GetStartAddress(), rhs.GetSize()); - } + constexpr bool Contains(const MemoryRegion &rhs) const { + return this->Contains(rhs.GetStartAddress(), rhs.GetSize()); + } - template requires (std::is_same::value || util::is_pod::value) - ALWAYS_INLINE T *GetPointer() const { - return reinterpret_cast(this->GetAddress()); - } + template requires (std::is_same::value || util::is_pod::value) + ALWAYS_INLINE T *GetPointer() const { + return reinterpret_cast(this->GetAddress()); + } - template requires (std::is_same::value || util::is_pod::value) - ALWAYS_INLINE T *GetEndPointer() const { - return reinterpret_cast(this->GetEndAddress()); - } + template requires (std::is_same::value || util::is_pod::value) + ALWAYS_INLINE T *GetEndPointer() const { + return reinterpret_cast(this->GetEndAddress()); + } }; constexpr inline const MemoryRegion MemoryRegionVirtual = MemoryRegion(UINT64_C(0x1F0000000), 2_MB); diff --git a/libraries/libexosphere/source/crypto/crypto_aes_impl_security_engine.cpp b/libraries/libexosphere/source/crypto/crypto_aes_impl_security_engine.cpp index 2f9e1b8d7..0cf3f4b49 100644 --- a/libraries/libexosphere/source/crypto/crypto_aes_impl_security_engine.cpp +++ b/libraries/libexosphere/source/crypto/crypto_aes_impl_security_engine.cpp @@ -37,7 +37,7 @@ namespace ams::crypto::impl { AMS_UNUSED(key_size, is_encrypt); /* Set the security engine keyslot. */ - this->slot = *static_cast(key); + m_slot = *static_cast(key); } template @@ -48,14 +48,14 @@ namespace ams::crypto::impl { if constexpr (KeySize == 16) { /* Aes 128. */ - se::EncryptAes128(dst, dst_size, this->slot, src, src_size); + se::EncryptAes128(dst, dst_size, m_slot, src, src_size); } else if constexpr (KeySize == 24) { /* Aes 192. */ - /* TODO: se::EncryptAes192(dst, dst_size, this->slot, src, src_size); */ + /* TODO: se::EncryptAes192(dst, dst_size, m_slot, src, src_size); */ AMS_UNUSED(dst, dst_size, src, src_size); } else if constexpr (KeySize == 32) { /* Aes 256. */ - /* TODO: se::EncryptAes256(dst, dst_size, this->slot, src, src_size); */ + /* TODO: se::EncryptAes256(dst, dst_size, m_slot, src, src_size); */ AMS_UNUSED(dst, dst_size, src, src_size); } else { /* Invalid key size. */ @@ -71,14 +71,14 @@ namespace ams::crypto::impl { if constexpr (KeySize == 16) { /* Aes 128. */ - se::DecryptAes128(dst, dst_size, this->slot, src, src_size); + se::DecryptAes128(dst, dst_size, m_slot, src, src_size); } else if constexpr (KeySize == 24) { /* Aes 192. */ - /* TODO: se::DecryptAes192(dst, dst_size, this->slot, src, src_size); */ + /* TODO: se::DecryptAes192(dst, dst_size, m_slot, src, src_size); */ AMS_UNUSED(dst, dst_size, src, src_size); } else if constexpr (KeySize == 32) { /* Aes 256. */ - /* TODO: se::DecryptAes256(dst, dst_size, this->slot, src, src_size); */ + /* TODO: se::DecryptAes256(dst, dst_size, m_slot, src, src_size); */ AMS_UNUSED(dst, dst_size, src, src_size); } else { /* Invalid key size. */ diff --git a/libraries/libvapours/include/vapours/crypto/crypto_aes_ctr_encryptor_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_aes_ctr_encryptor_decryptor.hpp index 59ad09043..3fa27856c 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_aes_ctr_encryptor_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_aes_ctr_encryptor_decryptor.hpp @@ -38,8 +38,8 @@ namespace ams::crypto { static constexpr size_t BlockSize = CtrImpl::BlockSize; static constexpr size_t IvSize = CtrImpl::BlockSize; private: - AesImpl aes_impl; - CtrImpl ctr_impl; + AesImpl m_aes_impl; + CtrImpl m_ctr_impl; public: AesCtrCryptor() { /* ... */ } @@ -52,16 +52,16 @@ namespace ams::crypto { AMS_ASSERT(iv_size == IvSize); AMS_ASSERT(offset >= 0); - this->aes_impl.Initialize(key, key_size); - this->ctr_impl.Initialize(std::addressof(this->aes_impl), iv, iv_size, offset); + m_aes_impl.Initialize(key, key_size); + m_ctr_impl.Initialize(std::addressof(m_aes_impl), iv, iv_size, offset); } void SwitchMessage(const void *iv, size_t iv_size) { - return this->ctr_impl.SwitchMessage(iv, iv_size); + return m_ctr_impl.SwitchMessage(iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->ctr_impl.Update(dst, dst_size, src, src_size); + return m_ctr_impl.Update(dst, dst_size, src, src_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_aes_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_aes_decryptor.hpp index db8a7110f..3983450e4 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_aes_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_aes_decryptor.hpp @@ -33,20 +33,20 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t RoundKeySize = Impl::RoundKeySize; private: - Impl impl; + Impl m_impl; public: AesDecryptor() { /* ... */ } void Initialize(const void *key, size_t key_size) { - this->impl.Initialize(key, key_size, false); + m_impl.Initialize(key, key_size, false); } void DecryptBlock(void *dst, size_t dst_size, const void *src, size_t src_size) const { - return this->impl.DecryptBlock(dst, dst_size, src, src_size); + return m_impl.DecryptBlock(dst, dst_size, src, src_size); } const u8 *GetRoundKey() const { - return this->impl.GetRoundKey(); + return m_impl.GetRoundKey(); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_aes_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_aes_encryptor.hpp index 27209eb90..d305acc88 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_aes_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_aes_encryptor.hpp @@ -33,20 +33,20 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t RoundKeySize = Impl::RoundKeySize; private: - Impl impl; + Impl m_impl; public: AesEncryptor() { /* ... */ } void Initialize(const void *key, size_t key_size) { - this->impl.Initialize(key, key_size, true); + m_impl.Initialize(key, key_size, true); } void EncryptBlock(void *dst, size_t dst_size, const void *src, size_t src_size) const { - return this->impl.EncryptBlock(dst, dst_size, src, src_size); + return m_impl.EncryptBlock(dst, dst_size, src, src_size); } const u8 *GetRoundKey() const { - return this->impl.GetRoundKey(); + return m_impl.GetRoundKey(); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_aes_gcm_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_aes_gcm_encryptor.hpp index 41a3d7e8e..f93cdfafe 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_aes_gcm_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_aes_gcm_encryptor.hpp @@ -37,30 +37,30 @@ namespace ams::crypto { static constexpr size_t BlockSize = AesImpl::BlockSize; static constexpr size_t MacSize = AesImpl::BlockSize; private: - AesImpl aes_impl; - GcmImpl gcm_impl; + AesImpl m_aes_impl; + GcmImpl m_gcm_impl; public: AesGcmEncryptor() { /* ... */ } void Initialize(const void *key, size_t key_size, const void *iv, size_t iv_size) { - this->aes_impl.Initialize(key, key_size); - this->gcm_impl.Initialize(std::addressof(this->aes_impl), iv, iv_size); + m_aes_impl.Initialize(key, key_size); + m_gcm_impl.Initialize(std::addressof(m_aes_impl), iv, iv_size); } void Reset(const void *iv, size_t iv_size) { - this->gcm_impl.Reset(iv, iv_size); + m_gcm_impl.Reset(iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->gcm_impl.Update(dst, dst_size, src, src_size); + return m_gcm_impl.Update(dst, dst_size, src, src_size); } void UpdateAad(const void *aad, size_t aad_size) { - return this->gcm_impl.UpdateAad(aad, aad_size); + return m_gcm_impl.UpdateAad(aad, aad_size); } void GetMac(void *dst, size_t dst_size) { - return this->gcm_impl.GetMac(dst, dst_size); + return m_gcm_impl.GetMac(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_aes_xts_encryptor_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_aes_xts_encryptor_decryptor.hpp index bc466041b..0a6fd55c3 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_aes_xts_encryptor_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_aes_xts_encryptor_decryptor.hpp @@ -42,9 +42,9 @@ namespace ams::crypto { static_assert(AesImpl1::KeySize == AesImpl2::KeySize); static_assert(AesImpl1::BlockSize == AesImpl2::BlockSize); private: - AesImpl1 aes_impl_1; - AesImpl2 aes_impl_2; - XtsImpl xts_impl; + AesImpl1 m_aes_impl_1; + AesImpl2 m_aes_impl_2; + XtsImpl m_xts_impl; public: AesXtsCryptor() { /* ... */ } @@ -52,17 +52,17 @@ namespace ams::crypto { AMS_ASSERT(key_size == KeySize); AMS_ASSERT(iv_size == IvSize); - this->aes_impl_1.Initialize(key1, key_size); - this->aes_impl_2.Initialize(key2, key_size); - this->xts_impl.Initialize(std::addressof(this->aes_impl_1), std::addressof(this->aes_impl_2), iv, iv_size); + m_aes_impl_1.Initialize(key1, key_size); + m_aes_impl_2.Initialize(key2, key_size); + m_xts_impl.Initialize(std::addressof(m_aes_impl_1), std::addressof(m_aes_impl_2), iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->xts_impl.Update(dst, dst_size, src, src_size); + return m_xts_impl.Update(dst, dst_size, src, src_size); } size_t Finalize(void *dst, size_t dst_size) { - return this->xts_impl.Finalize(dst, dst_size); + return m_xts_impl.Finalize(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_ctr_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_ctr_decryptor.hpp index 9ab7200aa..f6761e651 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_ctr_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_ctr_decryptor.hpp @@ -35,24 +35,24 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t IvSize = Impl::IvSize; private: - Impl impl; + Impl m_impl; public: CtrDecryptor() { /* ... */ } void Initialize(const BlockCipher *cipher, const void *iv, size_t iv_size) { - this->impl.Initialize(cipher, iv, iv_size); + m_impl.Initialize(cipher, iv, iv_size); } void Initialize(const BlockCipher *cipher, const void *iv, size_t iv_size, s64 offset) { - this->impl.Initialize(cipher, iv, iv_size, offset); + m_impl.Initialize(cipher, iv, iv_size, offset); } void SwitchMessage(const void *iv, size_t iv_size) { - this->impl.SwitchMessage(iv, iv_size); + m_impl.SwitchMessage(iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->impl.Update(dst, dst_size, src, src_size); + return m_impl.Update(dst, dst_size, src, src_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_ctr_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_ctr_encryptor.hpp index d477b6539..a05508d69 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_ctr_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_ctr_encryptor.hpp @@ -35,24 +35,24 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t IvSize = Impl::IvSize; private: - Impl impl; + Impl m_impl; public: CtrEncryptor() { /* ... */ } void Initialize(const BlockCipher *cipher, const void *iv, size_t iv_size) { - this->impl.Initialize(cipher, iv, iv_size); + m_impl.Initialize(cipher, iv, iv_size); } void Initialize(const BlockCipher *cipher, const void *iv, size_t iv_size, s64 offset) { - this->impl.Initialize(cipher, iv, iv_size, offset); + m_impl.Initialize(cipher, iv, iv_size, offset); } void SwitchMessage(const void *iv, size_t iv_size) { - this->impl.SwitchMessage(iv, iv_size); + m_impl.SwitchMessage(iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->impl.Update(dst, dst_size, src, src_size); + return m_impl.Update(dst, dst_size, src, src_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_gcm_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_gcm_encryptor.hpp index ca8fb9335..88bac3995 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_gcm_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_gcm_encryptor.hpp @@ -35,29 +35,29 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t MacSize = Impl::MacSize; private: - Impl impl; + Impl m_impl; public: GcmEncryptor() { /* ... */ } void Initialize(const BlockCipher *cipher, const void *iv, size_t iv_size) { - this->impl.Initialize(cipher); - this->impl.Reset(iv, iv_size); + m_impl.Initialize(cipher); + m_impl.Reset(iv, iv_size); } void Reset(const void *iv, size_t iv_size) { - this->impl.Reset(iv, iv_size); + m_impl.Reset(iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->impl.Update(dst, dst_size, src, src_size); + return m_impl.Update(dst, dst_size, src, src_size); } void UpdateAad(const void *aad, size_t aad_size) { - return this->impl.UpdateAad(aad, aad_size); + return m_impl.UpdateAad(aad, aad_size); } void GetMac(void *dst, size_t dst_size) { - return this->impl.GetMac(dst, dst_size); + return m_impl.GetMac(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_hmac_generator.hpp b/libraries/libvapours/include/vapours/crypto/crypto_hmac_generator.hpp index 432b35b5f..bfa00f7ad 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_hmac_generator.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_hmac_generator.hpp @@ -32,20 +32,20 @@ namespace ams::crypto { static constexpr size_t HashSize = Impl::HashSize; static constexpr size_t BlockSize = Impl::BlockSize; private: - Impl impl; + Impl m_impl; public: HmacGenerator() { /* ... */ } void Initialize(const void *key, size_t key_size) { - return this->impl.Initialize(key, key_size); + return m_impl.Initialize(key, key_size); } void Update(const void *data, size_t size) { - return this->impl.Update(data, size); + return m_impl.Update(data, size); } void GetMac(void *dst, size_t dst_size) { - return this->impl.GetMac(dst, dst_size); + return m_impl.GetMac(dst, dst_size); } }; } diff --git a/libraries/libvapours/include/vapours/crypto/crypto_rsa_calculator.hpp b/libraries/libvapours/include/vapours/crypto/crypto_rsa_calculator.hpp index 8ec80dbf1..5e8b62cfd 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_rsa_calculator.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_rsa_calculator.hpp @@ -29,17 +29,17 @@ namespace ams::crypto { public: static constexpr inline size_t RequiredWorkBufferSize = 0x10 * ModulusSize; private: - impl::StaticBigNum modulus; - impl::StaticBigNum exponent; + impl::StaticBigNum m_modulus; + impl::StaticBigNum m_exponent; public: RsaCalculator() { /* ... */ } - ~RsaCalculator() { this->exponent.ClearToZero(); } + ~RsaCalculator() { m_exponent.ClearToZero(); } bool Initialize(const void *mod, size_t mod_size, const void *exp, size_t exp_size) { - if (!this->modulus.Import(mod, mod_size) || this->modulus.IsZero()) { + if (!m_modulus.Import(mod, mod_size) || m_modulus.IsZero()) { return false; } - if (!this->exponent.Import(exp, exp_size) || this->exponent.IsZero()) { + if (!m_exponent.Import(exp, exp_size) || m_exponent.IsZero()) { return false; } return true; @@ -48,7 +48,7 @@ namespace ams::crypto { bool ExpMod(void *dst, const void *src, size_t size, void *work_buf, size_t work_buf_size) { AMS_ASSERT(work_buf_size >= RequiredWorkBufferSize); - return this->modulus.ExpMod(dst, src, size, this->exponent, static_cast(work_buf), work_buf_size); + return m_modulus.ExpMod(dst, src, size, m_exponent, static_cast(work_buf), work_buf_size); } bool ExpMod(void *dst, const void *src, size_t size) { diff --git a/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_decryptor.hpp index 4394b4b41..fb3a70215 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_decryptor.hpp @@ -39,23 +39,23 @@ namespace ams::crypto { Done, }; private: - RsaCalculator calculator; - Hash hash; - bool set_label_digest; - u8 label_digest[HashSize]; - State state; + RsaCalculator m_calculator; + Hash m_hash; + bool m_set_label_digest; + u8 m_label_digest[HashSize]; + State m_state; public: - RsaOaepDecryptor() : set_label_digest(false), state(State::None) { std::memset(this->label_digest, 0, sizeof(this->label_digest)); } + RsaOaepDecryptor() : m_set_label_digest(false), m_state(State::None) { std::memset(m_label_digest, 0, sizeof(m_label_digest)); } ~RsaOaepDecryptor() { - ClearMemory(this->label_digest, sizeof(this->label_digest)); + ClearMemory(m_label_digest, sizeof(m_label_digest)); } bool Initialize(const void *mod, size_t mod_size, const void *exp, size_t exp_size) { - this->hash.Initialize(); - this->set_label_digest = false; - if (this->calculator.Initialize(mod, mod_size, exp, exp_size)) { - this->state = State::Initialized; + m_hash.Initialize(); + m_set_label_digest = false; + if (m_calculator.Initialize(mod, mod_size, exp, exp_size)) { + m_state = State::Initialized; return true; } else { return false; @@ -63,58 +63,58 @@ namespace ams::crypto { } void UpdateLabel(const void *data, size_t size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); - this->hash.Update(data, size); + m_hash.Update(data, size); } void SetLabelDigest(const void *digest, size_t digest_size) { - AMS_ASSERT(this->state == State::Initialized); - AMS_ABORT_UNLESS(digest_size == sizeof(this->label_digest)); + AMS_ASSERT(m_state == State::Initialized); + AMS_ABORT_UNLESS(digest_size == sizeof(m_label_digest)); - std::memcpy(this->label_digest, digest, digest_size); - this->set_label_digest = true; + std::memcpy(m_label_digest, digest, digest_size); + m_set_label_digest = true; } size_t Decrypt(void *dst, size_t dst_size, const void *src, size_t src_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); impl::RsaOaepImpl impl; u8 message[BlockSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, src, src_size)) { + if (!m_calculator.ExpMod(message, src, src_size)) { std::memset(dst, 0, dst_size); return false; } - if (!this->set_label_digest) { - this->hash.GetHash(this->label_digest, sizeof(this->label_digest)); + if (!m_set_label_digest) { + m_hash.GetHash(m_label_digest, sizeof(m_label_digest)); } - ON_SCOPE_EXIT { this->state = State::Done; }; + ON_SCOPE_EXIT { m_state = State::Done; }; - return impl.Decode(dst, dst_size, this->label_digest, sizeof(this->label_digest), message, sizeof(message)); + return impl.Decode(dst, dst_size, m_label_digest, sizeof(m_label_digest), message, sizeof(message)); } size_t Decrypt(void *dst, size_t dst_size, const void *src, size_t src_size, void *work_buf, size_t work_buf_size) { - AMS_ASSERT(this->state == State::Initialized); - ON_SCOPE_EXIT { this->state = State::Done; }; + AMS_ASSERT(m_state == State::Initialized); + ON_SCOPE_EXIT { m_state = State::Done; }; impl::RsaOaepImpl impl; u8 message[BlockSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, src, src_size, work_buf, work_buf_size)) { + if (!m_calculator.ExpMod(message, src, src_size, work_buf, work_buf_size)) { return false; } - if (!this->set_label_digest) { - this->hash.GetHash(this->label_digest, sizeof(this->label_digest)); - this->set_label_digest = true; + if (!m_set_label_digest) { + m_hash.GetHash(m_label_digest, sizeof(m_label_digest)); + m_set_label_digest = true; } - return impl.Decode(dst, dst_size, this->label_digest, sizeof(this->label_digest), message, sizeof(message)); + return impl.Decode(dst, dst_size, m_label_digest, sizeof(m_label_digest), message, sizeof(message)); } static size_t Decrypt(void *dst, size_t dst_size, const void *mod, size_t mod_size, const void *exp, size_t exp_size, const void *msg, size_t msg_size, const void *lab, size_t lab_size) { diff --git a/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_encryptor.hpp index 8ed058265..af673b739 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_rsa_oaep_encryptor.hpp @@ -39,23 +39,23 @@ namespace ams::crypto { Done, }; private: - RsaCalculator calculator; - Hash hash; - bool set_label_digest; - u8 label_digest[HashSize]; - State state; + RsaCalculator m_calculator; + Hash m_hash; + bool m_set_label_digest; + u8 m_label_digest[HashSize]; + State m_state; public: - RsaOaepEncryptor() : set_label_digest(false), state(State::None) { std::memset(this->label_digest, 0, sizeof(this->label_digest)); } + RsaOaepEncryptor() : m_set_label_digest(false), m_state(State::None) { std::memset(m_label_digest, 0, sizeof(m_label_digest)); } ~RsaOaepEncryptor() { - ClearMemory(this->label_digest, sizeof(this->label_digest)); + ClearMemory(m_label_digest, sizeof(m_label_digest)); } bool Initialize(const void *mod, size_t mod_size, const void *exp, size_t exp_size) { - this->hash.Initialize(); - this->set_label_digest = false; - if (this->calculator.Initialize(mod, mod_size, exp, exp_size)) { - this->state = State::Initialized; + m_hash.Initialize(); + m_set_label_digest = false; + if (m_calculator.Initialize(mod, mod_size, exp, exp_size)) { + m_state = State::Initialized; return true; } else { return false; @@ -63,54 +63,54 @@ namespace ams::crypto { } void UpdateLabel(const void *data, size_t size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); - this->hash.Update(data, size); + m_hash.Update(data, size); } void SetLabelDigest(const void *digest, size_t digest_size) { - AMS_ASSERT(this->state == State::Initialized); - AMS_ABORT_UNLESS(digest_size == sizeof(this->label_digest)); + AMS_ASSERT(m_state == State::Initialized); + AMS_ABORT_UNLESS(digest_size == sizeof(m_label_digest)); - std::memcpy(this->label_digest, digest, digest_size); - this->set_label_digest = true; + std::memcpy(m_label_digest, digest, digest_size); + m_set_label_digest = true; } bool Encrypt(void *dst, size_t dst_size, const void *src, size_t src_size, const void *salt, size_t salt_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); impl::RsaOaepImpl impl; - if (!this->set_label_digest) { - this->hash.GetHash(this->label_digest, sizeof(this->label_digest)); + if (!m_set_label_digest) { + m_hash.GetHash(m_label_digest, sizeof(m_label_digest)); } - impl.Encode(dst, dst_size, this->label_digest, sizeof(this->label_digest), src, src_size, salt, salt_size); + impl.Encode(dst, dst_size, m_label_digest, sizeof(m_label_digest), src, src_size, salt, salt_size); - if (!this->calculator.ExpMod(dst, dst, dst_size)) { + if (!m_calculator.ExpMod(dst, dst, dst_size)) { std::memset(dst, 0, dst_size); return false; } - this->state = State::Done; + m_state = State::Done; return true; } bool Encrypt(void *dst, size_t dst_size, const void *src, size_t src_size, const void *salt, size_t salt_size, void *work, size_t work_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); impl::RsaOaepImpl impl; - if (!this->set_label_digest) { - this->hash.GetHash(this->label_digest, sizeof(this->label_digest)); + if (!m_set_label_digest) { + m_hash.GetHash(m_label_digest, sizeof(m_label_digest)); } - impl.Encode(dst, dst_size, this->label_digest, sizeof(this->label_digest), src, src_size, salt, salt_size); + impl.Encode(dst, dst_size, m_label_digest, sizeof(m_label_digest), src, src_size, salt, salt_size); - if (!this->calculator.ExpMod(dst, dst, dst_size, work, work_size)) { + if (!m_calculator.ExpMod(dst, dst, dst_size, work, work_size)) { std::memset(dst, 0, dst_size); return false; } - this->state = State::Done; + m_state = State::Done; return true; } diff --git a/libraries/libvapours/include/vapours/crypto/crypto_rsa_pss_verifier.hpp b/libraries/libvapours/include/vapours/crypto/crypto_rsa_pss_verifier.hpp index 0ce3d3a62..8a57dfc9a 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_rsa_pss_verifier.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_rsa_pss_verifier.hpp @@ -41,17 +41,17 @@ namespace ams::crypto { Done, }; private: - RsaCalculator calculator; - Hash hash; - State state; + RsaCalculator m_calculator; + Hash m_hash; + State m_state; public: - RsaPssVerifier() : state(State::None) { /* ... */ } + RsaPssVerifier() : m_state(State::None) { /* ... */ } ~RsaPssVerifier() { } bool Initialize(const void *mod, size_t mod_size, const void *exp, size_t exp_size) { - this->hash.Initialize(); - if (this->calculator.Initialize(mod, mod_size, exp, exp_size)) { - this->state = State::Initialized; + m_hash.Initialize(); + if (m_calculator.Initialize(mod, mod_size, exp, exp_size)) { + m_state = State::Initialized; return true; } else { return false; @@ -59,62 +59,62 @@ namespace ams::crypto { } void Update(const void *data, size_t size) { - return this->hash.Update(data, size); + return m_hash.Update(data, size); } bool Verify(const void *signature, size_t size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); AMS_ASSERT(size == SignatureSize); AMS_UNUSED(size); - ON_SCOPE_EXIT { this->state = State::Done; }; + ON_SCOPE_EXIT { m_state = State::Done; }; impl::RsaPssImpl impl; u8 message[SignatureSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, signature, SignatureSize)) { + if (!m_calculator.ExpMod(message, signature, SignatureSize)) { return false; } u8 calc_hash[Hash::HashSize]; - this->hash.GetHash(calc_hash, sizeof(calc_hash)); + m_hash.GetHash(calc_hash, sizeof(calc_hash)); ON_SCOPE_EXIT { ClearMemory(calc_hash, sizeof(calc_hash)); }; return impl.Verify(message, sizeof(message), calc_hash, sizeof(calc_hash)); } bool Verify(const void *signature, size_t size, void *work_buf, size_t work_buf_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); AMS_ASSERT(size == SignatureSize); AMS_UNUSED(size); - ON_SCOPE_EXIT { this->state = State::Done; }; + ON_SCOPE_EXIT { m_state = State::Done; }; impl::RsaPssImpl impl; u8 message[SignatureSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, signature, SignatureSize, work_buf, work_buf_size)) { + if (!m_calculator.ExpMod(message, signature, SignatureSize, work_buf, work_buf_size)) { return false; } u8 calc_hash[Hash::HashSize]; - this->hash.GetHash(calc_hash, sizeof(calc_hash)); + m_hash.GetHash(calc_hash, sizeof(calc_hash)); ON_SCOPE_EXIT { ClearMemory(calc_hash, sizeof(calc_hash)); }; return impl.Verify(message, sizeof(message), calc_hash, sizeof(calc_hash)); } bool VerifyWithHash(const void *signature, size_t size, const void *hash, size_t hash_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); AMS_ASSERT(size == SignatureSize); AMS_UNUSED(size); - ON_SCOPE_EXIT { this->state = State::Done; }; + ON_SCOPE_EXIT { m_state = State::Done; }; impl::RsaPssImpl impl; u8 message[SignatureSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, signature, SignatureSize)) { + if (!m_calculator.ExpMod(message, signature, SignatureSize)) { return false; } @@ -122,16 +122,16 @@ namespace ams::crypto { } bool VerifyWithHash(const void *signature, size_t size, const void *hash, size_t hash_size, void *work_buf, size_t work_buf_size) { - AMS_ASSERT(this->state == State::Initialized); + AMS_ASSERT(m_state == State::Initialized); AMS_ASSERT(size == SignatureSize); AMS_UNUSED(size); - ON_SCOPE_EXIT { this->state = State::Done; }; + ON_SCOPE_EXIT { m_state = State::Done; }; impl::RsaPssImpl impl; u8 message[SignatureSize]; ON_SCOPE_EXIT { ClearMemory(message, sizeof(message)); }; - if (!this->calculator.ExpMod(message, signature, SignatureSize, work_buf, work_buf_size)) { + if (!m_calculator.ExpMod(message, signature, SignatureSize, work_buf, work_buf_size)) { return false; } diff --git a/libraries/libvapours/include/vapours/crypto/crypto_sha1_generator.hpp b/libraries/libvapours/include/vapours/crypto/crypto_sha1_generator.hpp index 6e3c72b60..3cf7f7c45 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_sha1_generator.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_sha1_generator.hpp @@ -41,20 +41,20 @@ namespace ams::crypto { }; static constexpr size_t Asn1IdentifierSize = util::size(Asn1Identifier); private: - Impl impl; + Impl m_impl; public: Sha1Generator() { /* ... */ } void Initialize() { - this->impl.Initialize(); + m_impl.Initialize(); } void Update(const void *data, size_t size) { - this->impl.Update(data, size); + m_impl.Update(data, size); } void GetHash(void *dst, size_t size) { - this->impl.GetHash(dst, size); + m_impl.GetHash(dst, size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_sha256_generator.hpp b/libraries/libvapours/include/vapours/crypto/crypto_sha256_generator.hpp index 34641cd92..bdab35f97 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_sha256_generator.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_sha256_generator.hpp @@ -46,36 +46,36 @@ namespace ams::crypto { }; static constexpr size_t Asn1IdentifierSize = util::size(Asn1Identifier); private: - Impl impl; + Impl m_impl; public: Sha256Generator() { /* ... */ } void Initialize() { - this->impl.Initialize(); + m_impl.Initialize(); } void Update(const void *data, size_t size) { - this->impl.Update(data, size); + m_impl.Update(data, size); } void GetHash(void *dst, size_t size) { - this->impl.GetHash(dst, size); + m_impl.GetHash(dst, size); } void InitializeWithContext(const Sha256Context *context) { - this->impl.InitializeWithContext(context); + m_impl.InitializeWithContext(context); } size_t GetContext(Sha256Context *context) const { - return this->impl.GetContext(context); + return m_impl.GetContext(context); } size_t GetBufferedDataSize() const { - return this->impl.GetBufferedDataSize(); + return m_impl.GetBufferedDataSize(); } void GetBufferedData(void *dst, size_t dst_size) const { - return this->impl.GetBufferedData(dst, dst_size); + return m_impl.GetBufferedData(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_xts_decryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_xts_decryptor.hpp index 61f94cb27..70b6d5602 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_xts_decryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_xts_decryptor.hpp @@ -34,21 +34,21 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t IvSize = Impl::IvSize; private: - Impl impl; + Impl m_impl; public: XtsDecryptor() { /* ... */ } template void Initialize(const BlockCipher *cipher1, const BlockCipher2 *cipher2, const void *iv, size_t iv_size) { - this->impl.InitializeDecryption(cipher1, cipher2, iv, iv_size); + m_impl.InitializeDecryption(cipher1, cipher2, iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->impl.template Update(dst, dst_size, src, src_size); + return m_impl.template Update(dst, dst_size, src, src_size); } size_t Finalize(void *dst, size_t dst_size) { - return this->impl.FinalizeDecryption(dst, dst_size); + return m_impl.FinalizeDecryption(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/crypto_xts_encryptor.hpp b/libraries/libvapours/include/vapours/crypto/crypto_xts_encryptor.hpp index 679431ed8..9c6511f4b 100644 --- a/libraries/libvapours/include/vapours/crypto/crypto_xts_encryptor.hpp +++ b/libraries/libvapours/include/vapours/crypto/crypto_xts_encryptor.hpp @@ -34,21 +34,21 @@ namespace ams::crypto { static constexpr size_t BlockSize = Impl::BlockSize; static constexpr size_t IvSize = Impl::IvSize; private: - Impl impl; + Impl m_impl; public: XtsEncryptor() { /* ... */ } template void Initialize(const BlockCipher *cipher1, const BlockCipher2 *cipher2, const void *iv, size_t iv_size) { - this->impl.InitializeEncryption(cipher1, cipher2, iv, iv_size); + m_impl.InitializeEncryption(cipher1, cipher2, iv, iv_size); } size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) { - return this->impl.template Update(dst, dst_size, src, src_size); + return m_impl.template Update(dst, dst_size, src, src_size); } size_t Finalize(void *dst, size_t dst_size) { - return this->impl.FinalizeEncryption(dst, dst_size); + return m_impl.FinalizeEncryption(dst, dst_size); } }; diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_aes_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_aes_impl.hpp index ea567b5ff..3f662c5ad 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_aes_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_aes_impl.hpp @@ -31,10 +31,10 @@ namespace ams::crypto::impl { static constexpr size_t RoundKeySize = BlockSize * (RoundCount + 1); private: #ifdef ATMOSPHERE_IS_EXOSPHERE - int slot; + int m_slot; #endif #ifdef ATMOSPHERE_IS_STRATOSPHERE - u32 round_keys[RoundKeySize / sizeof(u32)]; + u32 m_round_keys[RoundKeySize / sizeof(u32)]; #endif public: ~AesImpl(); @@ -45,7 +45,7 @@ namespace ams::crypto::impl { #ifdef ATMOSPHERE_IS_STRATOSPHERE const u8 *GetRoundKey() const { - return reinterpret_cast(this->round_keys); + return reinterpret_cast(m_round_keys); } #endif }; diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_bignum.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_bignum.hpp index f279fa214..fb8dcbd16 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_bignum.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_bignum.hpp @@ -46,43 +46,43 @@ namespace ams::crypto::impl { private: friend class WordAllocator; private: - WordAllocator *allocator; - Word *buffer; - size_t count; + WordAllocator *m_allocator; + Word *m_buffer; + size_t m_count; private: - constexpr ALWAYS_INLINE Allocation(WordAllocator *a, Word *w, size_t c) : allocator(a), buffer(w), count(c) { /* ... */ } + constexpr ALWAYS_INLINE Allocation(WordAllocator *a, Word *w, size_t c) : m_allocator(a), m_buffer(w), m_count(c) { /* ... */ } public: - ALWAYS_INLINE ~Allocation() { if (allocator) { allocator->Free(this->buffer, this->count); } } + ALWAYS_INLINE ~Allocation() { if (m_allocator) { m_allocator->Free(m_buffer, m_count); } } - constexpr ALWAYS_INLINE Word *GetBuffer() const { return this->buffer; } - constexpr ALWAYS_INLINE size_t GetCount() const { return this->count; } - constexpr ALWAYS_INLINE bool IsValid() const { return this->buffer != nullptr; } + constexpr ALWAYS_INLINE Word *GetBuffer() const { return m_buffer; } + constexpr ALWAYS_INLINE size_t GetCount() const { return m_count; } + constexpr ALWAYS_INLINE bool IsValid() const { return m_buffer != nullptr; } }; friend class Allocation; private: - Word *buffer; - size_t count; - size_t max_count; - size_t min_count; + Word *m_buffer; + size_t m_count; + size_t m_max_count; + size_t m_min_count; private: ALWAYS_INLINE void Free(void *words, size_t num) { - this->buffer -= num; - this->count += num; + m_buffer -= num; + m_count += num; - AMS_ASSERT(words == this->buffer); + AMS_ASSERT(words == m_buffer); AMS_UNUSED(words); } public: - constexpr ALWAYS_INLINE WordAllocator(Word *buf, size_t c) : buffer(buf), count(c), max_count(c), min_count(c) { /* ... */ } + constexpr ALWAYS_INLINE WordAllocator(Word *buf, size_t c) : m_buffer(buf), m_count(c), m_max_count(c), m_min_count(c) { /* ... */ } ALWAYS_INLINE Allocation Allocate(size_t num) { - if (num <= this->count) { - Word *allocated = this->buffer; + if (num <= m_count) { + Word *allocated = m_buffer; - this->buffer += num; - this->count -= num; - this->min_count = std::min(this->count, this->min_count); + m_buffer += num; + m_count -= num; + m_min_count = std::min(m_count, m_min_count); return Allocation(this, allocated, num); } else { @@ -91,23 +91,23 @@ namespace ams::crypto::impl { } constexpr ALWAYS_INLINE size_t GetMaxUsedSize() const { - return (this->max_count - this->min_count) * sizeof(Word); + return (m_max_count - m_min_count) * sizeof(Word); } }; private: - Word *words; - size_t num_words; - size_t max_words; + Word *m_words; + size_t m_num_words; + size_t m_max_words; private: static void ImportImpl(Word *out, size_t out_size, const u8 *src, size_t src_size); static void ExportImpl(u8 *out, size_t out_size, const Word *src, size_t src_size); public: - constexpr BigNum() : words(), num_words(), max_words() { /* ... */ } + constexpr BigNum() : m_words(), m_num_words(), m_max_words() { /* ... */ } ~BigNum() { /* ... */ } constexpr void ReserveStatic(Word *buf, size_t capacity) { - this->words = buf; - this->max_words = capacity; + m_words = buf; + m_max_words = capacity; } bool Import(const void *src, size_t src_size); @@ -116,7 +116,7 @@ namespace ams::crypto::impl { size_t GetSize() const; bool IsZero() const { - return this->num_words == 0; + return m_num_words == 0; } bool ExpMod(void *dst, const void *src, size_t size, const BigNum &exp, u32 *work_buf, size_t work_buf_size) const; @@ -154,10 +154,10 @@ namespace ams::crypto::impl { static constexpr size_t NumWords = util::AlignUp(NumBits, BitsPerWord) / BitsPerWord; static constexpr size_t NumBytes = NumWords * sizeof(Word); private: - Word word_buf[NumWords]; + Word m_word_buf[NumWords]; public: - constexpr StaticBigNum() : word_buf() { - this->ReserveStatic(word_buf, NumWords); + constexpr StaticBigNum() : m_word_buf() { + this->ReserveStatic(m_word_buf, NumWords); } }; diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_ctr_mode_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_ctr_mode_impl.hpp index 809156abd..dc1427c3d 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_ctr_mode_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_ctr_mode_impl.hpp @@ -37,13 +37,13 @@ namespace ams::crypto::impl { State_Initialized, }; private: - const BlockCipher *block_cipher; - u8 counter[IvSize]; - u8 encrypted_counter[BlockSize]; - size_t buffer_offset; - State state; + const BlockCipher *m_block_cipher; + u8 m_counter[IvSize]; + u8 m_encrypted_counter[BlockSize]; + size_t m_buffer_offset; + State m_state; public: - CtrModeImpl() : state(State_None) { /* ... */ } + CtrModeImpl() : m_state(State_None) { /* ... */ } ~CtrModeImpl() { ClearMemory(this, sizeof(*this)); @@ -57,8 +57,8 @@ namespace ams::crypto::impl { AMS_ASSERT(iv_size == IvSize); AMS_ASSERT(offset >= 0); - this->block_cipher = block_cipher; - this->state = State_Initialized; + m_block_cipher = block_cipher; + m_state = State_Initialized; this->SwitchMessage(iv, iv_size); @@ -69,32 +69,32 @@ namespace ams::crypto::impl { } if (size_t remaining = static_cast(offset % BlockSize); remaining != 0) { - this->block_cipher->EncryptBlock(this->encrypted_counter, sizeof(this->encrypted_counter), this->counter, sizeof(this->counter)); + m_block_cipher->EncryptBlock(m_encrypted_counter, sizeof(m_encrypted_counter), m_counter, sizeof(m_counter)); this->IncrementCounter(); - this->buffer_offset = remaining; + m_buffer_offset = remaining; } } } void SwitchMessage(const void *iv, size_t iv_size) { - AMS_ASSERT(this->state == State_Initialized); + AMS_ASSERT(m_state == State_Initialized); AMS_ASSERT(iv_size == IvSize); - std::memcpy(this->counter, iv, iv_size); - this->buffer_offset = 0; + std::memcpy(m_counter, iv, iv_size); + m_buffer_offset = 0; } void IncrementCounter() { for (s32 i = IvSize - 1; i >= 0; --i) { - if (++this->counter[i] != 0) { + if (++m_counter[i] != 0) { break; } } } size_t Update(void *_dst, size_t dst_size, const void *_src, size_t src_size) { - AMS_ASSERT(this->state == State_Initialized); + AMS_ASSERT(m_state == State_Initialized); AMS_ASSERT(dst_size >= src_size); AMS_UNUSED(dst_size); @@ -102,10 +102,10 @@ namespace ams::crypto::impl { const u8 *src = static_cast(_src); size_t remaining = src_size; - if (this->buffer_offset > 0) { - const size_t xor_size = std::min(BlockSize - this->buffer_offset, remaining); + if (m_buffer_offset > 0) { + const size_t xor_size = std::min(BlockSize - m_buffer_offset, remaining); - const u8 *ctr = this->encrypted_counter + this->buffer_offset; + const u8 *ctr = m_encrypted_counter + m_buffer_offset; for (size_t i = 0; i < xor_size; i++) { dst[i] = src[i] ^ ctr[i]; } @@ -113,10 +113,10 @@ namespace ams::crypto::impl { src += xor_size; dst += xor_size; remaining -= xor_size; - this->buffer_offset += xor_size; + m_buffer_offset += xor_size; - if (this->buffer_offset == BlockSize) { - this->buffer_offset = 0; + if (m_buffer_offset == BlockSize) { + m_buffer_offset = 0; } } @@ -133,7 +133,7 @@ namespace ams::crypto::impl { if (remaining > 0) { this->ProcessBlock(dst, src, remaining); - this->buffer_offset = remaining; + m_buffer_offset = remaining; } return src_size; @@ -146,18 +146,18 @@ namespace ams::crypto::impl { u16 acc = 0; const u8 *block = reinterpret_cast(_block); for (s32 i = IvSize - 1; i >= 0; --i) { - acc += (this->counter[i] + block[i]); - this->counter[i] = acc & 0xFF; + acc += (m_counter[i] + block[i]); + m_counter[i] = acc & 0xFF; acc >>= 8; } } void ProcessBlock(u8 *dst, const u8 *src, size_t src_size) { - this->block_cipher->EncryptBlock(this->encrypted_counter, BlockSize, this->counter, IvSize); + m_block_cipher->EncryptBlock(m_encrypted_counter, BlockSize, m_counter, IvSize); this->IncrementCounter(); for (size_t i = 0; i < src_size; i++) { - dst[i] = src[i] ^ this->encrypted_counter[i]; + dst[i] = src[i] ^ m_encrypted_counter[i]; } } diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_gcm_mode_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_gcm_mode_impl.hpp index 3ba748260..30bca730d 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_gcm_mode_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_gcm_mode_impl.hpp @@ -63,23 +63,23 @@ namespace ams::crypto::impl { using CipherFunction = void (*)(void *dst_block, const void *src_block, const void *ctx); private: - State state; - const BlockCipher *block_cipher; - CipherFunction cipher_func; - u8 pad[sizeof(u64)]; - Block block_x; - Block block_y; - Block block_ek; - Block block_ek0; - Block block_tmp; - size_t aad_size; - size_t msg_size; - u32 aad_remaining; - u32 msg_remaining; - u32 counter; - Block h_mult_blocks[16]; + State m_state; + const BlockCipher *m_block_cipher; + CipherFunction m_cipher_func; + u8 m_pad[sizeof(u64)]; + Block m_block_x; + Block m_block_y; + Block m_block_ek; + Block m_block_ek0; + Block m_block_tmp; + size_t m_aad_size; + size_t m_msg_size; + u32 m_aad_remaining; + u32 m_msg_remaining; + u32 m_counter; + Block m_h_mult_blocks[16]; public: - GcmModeImpl() : state(State_None) { /* ... */ } + GcmModeImpl() : m_state(State_None) { /* ... */ } ~GcmModeImpl() { ClearMemory(this, sizeof(*this)); diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_hmac_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_hmac_impl.hpp index 9a02ae8ca..3f2c1ecd1 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_hmac_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_hmac_impl.hpp @@ -43,17 +43,17 @@ namespace ams::crypto::impl { State_Done = 2, }; private: - Hash hash_function; - u32 key[BlockSize / sizeof(u32)]; - u32 mac[MacSize / sizeof(u32)]; - State state; + Hash m_hash_function; + u32 m_key[BlockSize / sizeof(u32)]; + u32 m_mac[MacSize / sizeof(u32)]; + State m_state; public: - HmacImpl() : state(State_None) { /* ... */ } + HmacImpl() : m_state(State_None) { /* ... */ } ~HmacImpl() { - static_assert(offsetof(HmacImpl, hash_function) == 0); + static_assert(offsetof(HmacImpl, m_hash_function) == 0); /* Clear everything except for the hash function. */ - ClearMemory(reinterpret_cast(this) + sizeof(this->hash_function), sizeof(*this) - sizeof(this->hash_function)); + ClearMemory(reinterpret_cast(this) + sizeof(m_hash_function), sizeof(*this) - sizeof(m_hash_function)); } void Initialize(const void *key, size_t key_size); @@ -64,64 +64,64 @@ namespace ams::crypto::impl { template inline void HmacImpl::Initialize(const void *key, size_t key_size) { /* Clear the key storage. */ - std::memset(this->key, 0, sizeof(this->key)); + std::memset(m_key, 0, sizeof(m_key)); /* Set the key storage. */ if (key_size > BlockSize) { - this->hash_function.Initialize(); - this->hash_function.Update(key, key_size); - this->hash_function.GetHash(this->key, this->hash_function.HashSize); + m_hash_function.Initialize(); + m_hash_function.Update(key, key_size); + m_hash_function.GetHash(m_key, m_hash_function.HashSize); } else { - std::memcpy(this->key, key, key_size); + std::memcpy(m_key, key, key_size); } /* Xor the key with the ipad. */ - for (size_t i = 0; i < util::size(this->key); i++) { - this->key[i] ^= IpadMagic; + for (size_t i = 0; i < util::size(m_key); i++) { + m_key[i] ^= IpadMagic; } /* Update the hash function with the xor'd key. */ - this->hash_function.Initialize(); - this->hash_function.Update(this->key, BlockSize); + m_hash_function.Initialize(); + m_hash_function.Update(m_key, BlockSize); /* Mark initialized. */ - this->state = State_Initialized; + m_state = State_Initialized; } template inline void HmacImpl::Update(const void *data, size_t data_size) { - AMS_ASSERT(this->state == State_Initialized); + AMS_ASSERT(m_state == State_Initialized); - this->hash_function.Update(data, data_size); + m_hash_function.Update(data, data_size); } template inline void HmacImpl::GetMac(void *dst, size_t dst_size) { - AMS_ASSERT(this->state == State_Initialized || this->state == State_Done); + AMS_ASSERT(m_state == State_Initialized || m_state == State_Done); AMS_ASSERT(dst_size >= MacSize); AMS_UNUSED(dst_size); /* If we're not already finalized, get the final mac. */ - if (this->state == State_Initialized) { + if (m_state == State_Initialized) { /* Get the hash of ((key ^ ipad) || data). */ - this->hash_function.GetHash(this->mac, MacSize); + m_hash_function.GetHash(m_mac, MacSize); /* Xor the key with the opad. */ - for (size_t i = 0; i < util::size(this->key); i++) { - this->key[i] ^= IpadMagicXorOpadMagic; + for (size_t i = 0; i < util::size(m_key); i++) { + m_key[i] ^= IpadMagicXorOpadMagic; } /* Calculate the final mac as hash of ((key ^ opad) || hash((key ^ ipad) || data)) */ - this->hash_function.Initialize(); - this->hash_function.Update(this->key, BlockSize); - this->hash_function.Update(this->mac, MacSize); - this->hash_function.GetHash(this->mac, MacSize); + m_hash_function.Initialize(); + m_hash_function.Update(m_key, BlockSize); + m_hash_function.Update(m_mac, MacSize); + m_hash_function.GetHash(m_mac, MacSize); /* Set our state as done. */ - this->state = State_Done; + m_state = State_Done; } - std::memcpy(dst, this->mac, MacSize); + std::memcpy(dst, m_mac, MacSize); } } diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_sha1_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_sha1_impl.hpp index 545cf4497..1b15171ae 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_sha1_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_sha1_impl.hpp @@ -37,12 +37,12 @@ namespace ams::crypto::impl { bool finalized; }; private: - State state; + State m_state; public: Sha1Impl() { /* ... */ } ~Sha1Impl() { static_assert(std::is_trivially_destructible::value); - ClearMemory(std::addressof(this->state), sizeof(this->state)); + ClearMemory(std::addressof(m_state), sizeof(m_state)); } void Initialize(); diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_sha256_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_sha256_impl.hpp index a6db11a78..adcdf623f 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_sha256_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_sha256_impl.hpp @@ -42,12 +42,12 @@ namespace ams::crypto::impl { bool finalized; }; private: - State state; + State m_state; public: Sha256Impl() { /* ... */ } ~Sha256Impl() { static_assert(std::is_trivially_destructible::value); - ClearMemory(std::addressof(this->state), sizeof(this->state)); + ClearMemory(std::addressof(m_state), sizeof(m_state)); } void Initialize(); @@ -57,13 +57,13 @@ namespace ams::crypto::impl { void InitializeWithContext(const Sha256Context *context); size_t GetContext(Sha256Context *context) const; - size_t GetBufferedDataSize() const { return this->state.num_buffered; } + size_t GetBufferedDataSize() const { return m_state.num_buffered; } void GetBufferedData(void *dst, size_t dst_size) const { AMS_ASSERT(dst_size >= this->GetBufferedDataSize()); AMS_UNUSED(dst_size); - std::memcpy(dst, this->state.buffer, this->GetBufferedDataSize()); + std::memcpy(dst, m_state.buffer, this->GetBufferedDataSize()); } }; diff --git a/libraries/libvapours/include/vapours/crypto/impl/crypto_xts_mode_impl.hpp b/libraries/libvapours/include/vapours/crypto/impl/crypto_xts_mode_impl.hpp index 4909f6523..78136240b 100644 --- a/libraries/libvapours/include/vapours/crypto/impl/crypto_xts_mode_impl.hpp +++ b/libraries/libvapours/include/vapours/crypto/impl/crypto_xts_mode_impl.hpp @@ -38,15 +38,15 @@ namespace ams::crypto::impl { State_Done }; private: - u8 buffer[BlockSize]; - u8 tweak[BlockSize]; - u8 last_block[BlockSize]; - size_t num_buffered; - const void *cipher_ctx; - void (*cipher_func)(void *dst_block, const void *src_block, const void *cipher_ctx); - State state; + u8 m_buffer[BlockSize]; + u8 m_tweak[BlockSize]; + u8 m_last_block[BlockSize]; + size_t m_num_buffered; + const void *m_cipher_ctx; + void (*m_cipher_func)(void *dst_block, const void *src_block, const void *cipher_ctx); + State m_state; public: - XtsModeImpl() : num_buffered(0), state(State_None) { /* ... */ } + XtsModeImpl() : m_num_buffered(0), m_state(State_None) { /* ... */ } ~XtsModeImpl() { ClearMemory(this, sizeof(*this)); @@ -67,10 +67,10 @@ namespace ams::crypto::impl { AMS_ASSERT(tweak_size == IvSize); AMS_UNUSED(tweak_size); - cipher->EncryptBlock(this->tweak, IvSize, tweak, IvSize); + cipher->EncryptBlock(m_tweak, IvSize, tweak, IvSize); - this->num_buffered = 0; - this->state = State_Initialized; + m_num_buffered = 0; + m_state = State_Initialized; } void ProcessBlock(u8 *dst, const u8 *src); @@ -80,8 +80,8 @@ namespace ams::crypto::impl { static_assert(BlockCipher1::BlockSize == BlockSize); static_assert(BlockCipher2::BlockSize == BlockSize); - this->cipher_ctx = cipher1; - this->cipher_func = EncryptBlockCallback; + m_cipher_ctx = cipher1; + m_cipher_func = EncryptBlockCallback; this->Initialize(cipher2, tweak, tweak_size); } @@ -91,8 +91,8 @@ namespace ams::crypto::impl { static_assert(BlockCipher1::BlockSize == BlockSize); static_assert(BlockCipher2::BlockSize == BlockSize); - this->cipher_ctx = cipher1; - this->cipher_func = DecryptBlockCallback; + m_cipher_ctx = cipher1; + m_cipher_func = DecryptBlockCallback; this->Initialize(cipher2, tweak, tweak_size); } @@ -108,7 +108,7 @@ namespace ams::crypto::impl { } size_t GetBufferedDataSize() const { - return this->num_buffered; + return m_num_buffered; } constexpr size_t GetBlockSize() const { diff --git a/libraries/libvapours/include/vapours/device_code.hpp b/libraries/libvapours/include/vapours/device_code.hpp index 62daff6b1..831cf372b 100644 --- a/libraries/libvapours/include/vapours/device_code.hpp +++ b/libraries/libvapours/include/vapours/device_code.hpp @@ -29,11 +29,11 @@ namespace ams { /* TODO: Better understand device code components. */ class DeviceCode { private: - impl::DeviceCodeType inner_value; + impl::DeviceCodeType m_inner_value; public: - constexpr DeviceCode(impl::DeviceCodeType v) : inner_value(v) { /* ... */ } + constexpr DeviceCode(impl::DeviceCodeType v) : m_inner_value(v) { /* ... */ } - constexpr impl::DeviceCodeType GetInternalValue() const { return this->inner_value; } + constexpr impl::DeviceCodeType GetInternalValue() const { return m_inner_value; } constexpr bool operator==(const DeviceCode &rhs) const { return this->GetInternalValue() == rhs.GetInternalValue(); diff --git a/libraries/libvapours/include/vapours/freebsd/tree.hpp b/libraries/libvapours/include/vapours/freebsd/tree.hpp index 3e4c41087..7fb838f11 100644 --- a/libraries/libvapours/include/vapours/freebsd/tree.hpp +++ b/libraries/libvapours/include/vapours/freebsd/tree.hpp @@ -56,31 +56,31 @@ namespace ams::freebsd { template class RBEntry { private: - T *rbe_left = nullptr; - T *rbe_right = nullptr; - T *rbe_parent = nullptr; - RBColor rbe_color = RBColor::RB_BLACK; + T *m_rbe_left = nullptr; + T *m_rbe_right = nullptr; + T *m_rbe_parent = nullptr; + RBColor m_rbe_color = RBColor::RB_BLACK; public: - [[nodiscard]] constexpr ALWAYS_INLINE T *Left() { return this->rbe_left; } - [[nodiscard]] constexpr ALWAYS_INLINE const T *Left() const { return this->rbe_left; } + [[nodiscard]] constexpr ALWAYS_INLINE T *Left() { return m_rbe_left; } + [[nodiscard]] constexpr ALWAYS_INLINE const T *Left() const { return m_rbe_left; } - constexpr ALWAYS_INLINE void SetLeft(T *e) { this->rbe_left = e; } + constexpr ALWAYS_INLINE void SetLeft(T *e) { m_rbe_left = e; } - [[nodiscard]] constexpr ALWAYS_INLINE T *Right() { return this->rbe_right; } - [[nodiscard]] constexpr ALWAYS_INLINE const T *Right() const { return this->rbe_right; } + [[nodiscard]] constexpr ALWAYS_INLINE T *Right() { return m_rbe_right; } + [[nodiscard]] constexpr ALWAYS_INLINE const T *Right() const { return m_rbe_right; } - constexpr ALWAYS_INLINE void SetRight(T *e) { this->rbe_right = e; } + constexpr ALWAYS_INLINE void SetRight(T *e) { m_rbe_right = e; } - [[nodiscard]] constexpr ALWAYS_INLINE T *Parent() { return this->rbe_parent; } - [[nodiscard]] constexpr ALWAYS_INLINE const T *Parent() const { return this->rbe_parent; } + [[nodiscard]] constexpr ALWAYS_INLINE T *Parent() { return m_rbe_parent; } + [[nodiscard]] constexpr ALWAYS_INLINE const T *Parent() const { return m_rbe_parent; } - constexpr ALWAYS_INLINE void SetParent(T *e) { this->rbe_parent = e; } + constexpr ALWAYS_INLINE void SetParent(T *e) { m_rbe_parent = e; } - [[nodiscard]] constexpr ALWAYS_INLINE bool IsBlack() const { return this->rbe_color == RBColor::RB_BLACK; } - [[nodiscard]] constexpr ALWAYS_INLINE bool IsRed() const { return this->rbe_color == RBColor::RB_RED; } - [[nodiscard]] constexpr ALWAYS_INLINE RBColor Color() const { return this->rbe_color; } + [[nodiscard]] constexpr ALWAYS_INLINE bool IsBlack() const { return m_rbe_color == RBColor::RB_BLACK; } + [[nodiscard]] constexpr ALWAYS_INLINE bool IsRed() const { return m_rbe_color == RBColor::RB_RED; } + [[nodiscard]] constexpr ALWAYS_INLINE RBColor Color() const { return m_rbe_color; } - constexpr ALWAYS_INLINE void SetColor(RBColor c) { this->rbe_color = c; } + constexpr ALWAYS_INLINE void SetColor(RBColor c) { m_rbe_color = c; } }; template struct CheckRBEntry { static constexpr bool value = false; }; @@ -98,11 +98,11 @@ namespace ams::freebsd { template requires HasRBEntry class RBHead { private: - T *rbh_root = nullptr; + T *m_rbh_root = nullptr; public: - [[nodiscard]] constexpr ALWAYS_INLINE T *Root() { return this->rbh_root; } - [[nodiscard]] constexpr ALWAYS_INLINE const T *Root() const { return this->rbh_root; } - constexpr ALWAYS_INLINE void SetRoot(T *root) { this->rbh_root = root; } + [[nodiscard]] constexpr ALWAYS_INLINE T *Root() { return m_rbh_root; } + [[nodiscard]] constexpr ALWAYS_INLINE const T *Root() const { return m_rbh_root; } + constexpr ALWAYS_INLINE void SetRoot(T *root) { m_rbh_root = root; } [[nodiscard]] constexpr ALWAYS_INLINE bool IsEmpty() const { return this->Root() == nullptr; } }; diff --git a/libraries/libvapours/include/vapours/timespan.hpp b/libraries/libvapours/include/vapours/timespan.hpp index 5bd3735ed..435b787b4 100644 --- a/libraries/libvapours/include/vapours/timespan.hpp +++ b/libraries/libvapours/include/vapours/timespan.hpp @@ -24,7 +24,7 @@ namespace ams { struct TimeSpanType { public: - s64 ns; + s64 _ns; public: static constexpr ALWAYS_INLINE TimeSpanType FromNanoSeconds(s64 ns) { return {ns}; } static constexpr ALWAYS_INLINE TimeSpanType FromMicroSeconds(s64 ms) { return FromNanoSeconds(ms * INT64_C(1000)); } @@ -34,7 +34,7 @@ namespace ams { static constexpr ALWAYS_INLINE TimeSpanType FromHours(s64 h) { return FromMinutes(h * INT64_C(60)); } static constexpr ALWAYS_INLINE TimeSpanType FromDays(s64 d) { return FromHours(d * INT64_C(24)); } - constexpr ALWAYS_INLINE s64 GetNanoSeconds() const { return this->ns; } + constexpr ALWAYS_INLINE s64 GetNanoSeconds() const { return _ns; } constexpr ALWAYS_INLINE s64 GetMicroSeconds() const { return this->GetNanoSeconds() / (INT64_C(1000)); } constexpr ALWAYS_INLINE s64 GetMilliSeconds() const { return this->GetNanoSeconds() / (INT64_C(1000) * INT64_C(1000)); } constexpr ALWAYS_INLINE s64 GetSeconds() const { return this->GetNanoSeconds() / (INT64_C(1000) * INT64_C(1000) * INT64_C(1000)); } @@ -42,15 +42,15 @@ namespace ams { constexpr ALWAYS_INLINE s64 GetHours() const { return this->GetNanoSeconds() / (INT64_C(1000) * INT64_C(1000) * INT64_C(1000) * INT64_C( 60) * INT64_C( 60)); } constexpr ALWAYS_INLINE s64 GetDays() const { return this->GetNanoSeconds() / (INT64_C(1000) * INT64_C(1000) * INT64_C(1000) * INT64_C( 60) * INT64_C( 60) * INT64_C( 24)); } - constexpr ALWAYS_INLINE friend bool operator==(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns == rhs.ns; } - constexpr ALWAYS_INLINE friend bool operator!=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns != rhs.ns; } - constexpr ALWAYS_INLINE friend bool operator<=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns <= rhs.ns; } - constexpr ALWAYS_INLINE friend bool operator>=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns >= rhs.ns; } - constexpr ALWAYS_INLINE friend bool operator< (const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns < rhs.ns; } - constexpr ALWAYS_INLINE friend bool operator> (const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs.ns > rhs.ns; } + constexpr ALWAYS_INLINE friend bool operator==(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns == rhs._ns; } + constexpr ALWAYS_INLINE friend bool operator!=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns != rhs._ns; } + constexpr ALWAYS_INLINE friend bool operator<=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns <= rhs._ns; } + constexpr ALWAYS_INLINE friend bool operator>=(const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns >= rhs._ns; } + constexpr ALWAYS_INLINE friend bool operator< (const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns < rhs._ns; } + constexpr ALWAYS_INLINE friend bool operator> (const TimeSpanType &lhs, const TimeSpanType &rhs) { return lhs._ns > rhs._ns; } - constexpr ALWAYS_INLINE TimeSpanType &operator+=(const TimeSpanType &rhs) { this->ns += rhs.ns; return *this; } - constexpr ALWAYS_INLINE TimeSpanType &operator-=(const TimeSpanType &rhs) { this->ns -= rhs.ns; return *this; } + constexpr ALWAYS_INLINE TimeSpanType &operator+=(const TimeSpanType &rhs) { _ns += rhs._ns; return *this; } + constexpr ALWAYS_INLINE TimeSpanType &operator-=(const TimeSpanType &rhs) { _ns -= rhs._ns; return *this; } constexpr ALWAYS_INLINE friend TimeSpanType operator+(const TimeSpanType &lhs, const TimeSpanType &rhs) { TimeSpanType r(lhs); return r += rhs; } constexpr ALWAYS_INLINE friend TimeSpanType operator-(const TimeSpanType &lhs, const TimeSpanType &rhs) { TimeSpanType r(lhs); return r -= rhs; } @@ -61,13 +61,13 @@ namespace ams { private: using ZeroTag = const class ZeroTagImpl{} *; private: - TimeSpanType ts; + TimeSpanType m_ts; public: - constexpr ALWAYS_INLINE TimeSpan(ZeroTag z = nullptr) : ts(TimeSpanType::FromNanoSeconds(0)) { AMS_UNUSED(z); /* ... */ } - constexpr ALWAYS_INLINE TimeSpan(const TimeSpanType &t) : ts(t) { /* ... */ } + constexpr ALWAYS_INLINE TimeSpan(ZeroTag z = nullptr) : m_ts(TimeSpanType::FromNanoSeconds(0)) { AMS_UNUSED(z); /* ... */ } + constexpr ALWAYS_INLINE TimeSpan(const TimeSpanType &t) : m_ts(t) { /* ... */ } template - constexpr ALWAYS_INLINE TimeSpan(const std::chrono::duration& c) : ts(TimeSpanType::FromNanoSeconds(static_cast(c).count())) { /* ... */ } + constexpr ALWAYS_INLINE TimeSpan(const std::chrono::duration& c) : m_ts(TimeSpanType::FromNanoSeconds(static_cast(c).count())) { /* ... */ } public: static constexpr ALWAYS_INLINE TimeSpan FromNanoSeconds(s64 ns) { return TimeSpanType::FromNanoSeconds(ns); } static constexpr ALWAYS_INLINE TimeSpan FromMicroSeconds(s64 ms) { return TimeSpanType::FromMicroSeconds(ms); } @@ -77,29 +77,29 @@ namespace ams { static constexpr ALWAYS_INLINE TimeSpan FromHours(s64 h) { return TimeSpanType::FromHours(h); } static constexpr ALWAYS_INLINE TimeSpan FromDays(s64 d) { return TimeSpanType::FromDays(d); } - constexpr ALWAYS_INLINE s64 GetNanoSeconds() const { return this->ts.GetNanoSeconds(); } - constexpr ALWAYS_INLINE s64 GetMicroSeconds() const { return this->ts.GetMicroSeconds(); } - constexpr ALWAYS_INLINE s64 GetMilliSeconds() const { return this->ts.GetMilliSeconds(); } - constexpr ALWAYS_INLINE s64 GetSeconds() const { return this->ts.GetSeconds(); } - constexpr ALWAYS_INLINE s64 GetMinutes() const { return this->ts.GetMinutes(); } - constexpr ALWAYS_INLINE s64 GetHours() const { return this->ts.GetHours(); } - constexpr ALWAYS_INLINE s64 GetDays() const { return this->ts.GetDays(); } + constexpr ALWAYS_INLINE s64 GetNanoSeconds() const { return m_ts.GetNanoSeconds(); } + constexpr ALWAYS_INLINE s64 GetMicroSeconds() const { return m_ts.GetMicroSeconds(); } + constexpr ALWAYS_INLINE s64 GetMilliSeconds() const { return m_ts.GetMilliSeconds(); } + constexpr ALWAYS_INLINE s64 GetSeconds() const { return m_ts.GetSeconds(); } + constexpr ALWAYS_INLINE s64 GetMinutes() const { return m_ts.GetMinutes(); } + constexpr ALWAYS_INLINE s64 GetHours() const { return m_ts.GetHours(); } + constexpr ALWAYS_INLINE s64 GetDays() const { return m_ts.GetDays(); } - constexpr ALWAYS_INLINE friend bool operator==(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts == rhs.ts; } - constexpr ALWAYS_INLINE friend bool operator!=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts != rhs.ts; } - constexpr ALWAYS_INLINE friend bool operator<=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts <= rhs.ts; } - constexpr ALWAYS_INLINE friend bool operator>=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts >= rhs.ts; } - constexpr ALWAYS_INLINE friend bool operator< (const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts < rhs.ts; } - constexpr ALWAYS_INLINE friend bool operator> (const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.ts > rhs.ts; } + constexpr ALWAYS_INLINE friend bool operator==(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts == rhs.m_ts; } + constexpr ALWAYS_INLINE friend bool operator!=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts != rhs.m_ts; } + constexpr ALWAYS_INLINE friend bool operator<=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts <= rhs.m_ts; } + constexpr ALWAYS_INLINE friend bool operator>=(const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts >= rhs.m_ts; } + constexpr ALWAYS_INLINE friend bool operator< (const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts < rhs.m_ts; } + constexpr ALWAYS_INLINE friend bool operator> (const TimeSpan &lhs, const TimeSpan &rhs) { return lhs.m_ts > rhs.m_ts; } - constexpr ALWAYS_INLINE TimeSpan &operator+=(const TimeSpan &rhs) { this->ts += rhs.ts; return *this; } - constexpr ALWAYS_INLINE TimeSpan &operator-=(const TimeSpan &rhs) { this->ts -= rhs.ts; return *this; } + constexpr ALWAYS_INLINE TimeSpan &operator+=(const TimeSpan &rhs) { m_ts += rhs.m_ts; return *this; } + constexpr ALWAYS_INLINE TimeSpan &operator-=(const TimeSpan &rhs) { m_ts -= rhs.m_ts; return *this; } constexpr ALWAYS_INLINE friend TimeSpan operator+(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r += rhs; } constexpr ALWAYS_INLINE friend TimeSpan operator-(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r -= rhs; } constexpr ALWAYS_INLINE operator TimeSpanType() const { - return this->ts; + return m_ts; } }; diff --git a/libraries/libvapours/include/vapours/util/util_aligned_buffer.hpp b/libraries/libvapours/include/vapours/util/util_aligned_buffer.hpp index 6df4904e9..2fdb88ad8 100644 --- a/libraries/libvapours/include/vapours/util/util_aligned_buffer.hpp +++ b/libraries/libvapours/include/vapours/util/util_aligned_buffer.hpp @@ -27,9 +27,9 @@ namespace ams::util { static constexpr size_t AlignedSize = ((Size + Alignment - 1) / Alignment) * Alignment; static_assert(AlignedSize % Alignment == 0); private: - u8 buffer[Alignment + AlignedSize]; + u8 m_buffer[Alignment + AlignedSize]; public: - ALWAYS_INLINE operator u8 *() { return reinterpret_cast(util::AlignUp(reinterpret_cast(this->buffer), Alignment)); } + ALWAYS_INLINE operator u8 *() { return reinterpret_cast(util::AlignUp(reinterpret_cast(m_buffer), Alignment)); } }; } \ No newline at end of file diff --git a/libraries/libvapours/include/vapours/util/util_bitflagset.hpp b/libraries/libvapours/include/vapours/util/util_bitflagset.hpp index 9da69e9f4..c3cb78655 100644 --- a/libraries/libvapours/include/vapours/util/util_bitflagset.hpp +++ b/libraries/libvapours/include/vapours/util/util_bitflagset.hpp @@ -111,17 +111,17 @@ namespace ams::util { class Reference { friend struct BitFlagSet; private: - BitFlagSet *set; - s32 idx; + BitFlagSet *m_set; + s32 m_idx; private: - constexpr ALWAYS_INLINE Reference() : set(nullptr), idx(0) { /* ... */ } - constexpr ALWAYS_INLINE Reference(BitFlagSet &s, s32 i) : set(std::addressof(s)), idx(i) { /* ... */ } + constexpr ALWAYS_INLINE Reference() : m_set(nullptr), m_idx(0) { /* ... */ } + constexpr ALWAYS_INLINE Reference(BitFlagSet &s, s32 i) : m_set(std::addressof(s)), m_idx(i) { /* ... */ } public: - constexpr ALWAYS_INLINE Reference &operator=(bool en) { this->set->Set(this->idx, en); return *this; } - constexpr ALWAYS_INLINE Reference &operator=(const Reference &r) { this->set->Set(this->idx, r); return *this; } - constexpr ALWAYS_INLINE Reference &Negate() { this->set->Negate(this->idx); return *this; } - constexpr ALWAYS_INLINE operator bool() const { return this->set->Test(this->idx); } - constexpr ALWAYS_INLINE bool operator~() const { return !this->set->Test(this->idx); } + constexpr ALWAYS_INLINE Reference &operator=(bool en) { m_set->Set(m_idx, en); return *this; } + constexpr ALWAYS_INLINE Reference &operator=(const Reference &r) { m_set->Set(m_idx, r); return *this; } + constexpr ALWAYS_INLINE Reference &Negate() { m_set->Negate(m_idx); return *this; } + constexpr ALWAYS_INLINE operator bool() const { return m_set->Test(m_idx); } + constexpr ALWAYS_INLINE bool operator~() const { return !m_set->Test(m_idx); } }; template diff --git a/libraries/libvapours/include/vapours/util/util_bitset.hpp b/libraries/libvapours/include/vapours/util/util_bitset.hpp index c1389fde3..70919a29a 100644 --- a/libraries/libvapours/include/vapours/util/util_bitset.hpp +++ b/libraries/libvapours/include/vapours/util/util_bitset.hpp @@ -40,22 +40,22 @@ namespace ams::util { return Storage(1) << (FlagsPerWord - 1 - bit); } private: - Storage words[NumWords]; + Storage m_words[NumWords]; public: - constexpr ALWAYS_INLINE BitSet() : words() { /* ... */ } + constexpr ALWAYS_INLINE BitSet() : m_words() { /* ... */ } constexpr ALWAYS_INLINE void SetBit(size_t i) { - this->words[i / FlagsPerWord] |= GetBitMask(i % FlagsPerWord); + m_words[i / FlagsPerWord] |= GetBitMask(i % FlagsPerWord); } constexpr ALWAYS_INLINE void ClearBit(size_t i) { - this->words[i / FlagsPerWord] &= ~GetBitMask(i % FlagsPerWord); + m_words[i / FlagsPerWord] &= ~GetBitMask(i % FlagsPerWord); } constexpr ALWAYS_INLINE size_t CountLeadingZero() const { for (size_t i = 0; i < NumWords; i++) { - if (this->words[i]) { - return FlagsPerWord * i + CountLeadingZeroImpl(this->words[i]); + if (m_words[i]) { + return FlagsPerWord * i + CountLeadingZeroImpl(m_words[i]); } } return FlagsPerWord * NumWords; @@ -63,7 +63,7 @@ namespace ams::util { constexpr ALWAYS_INLINE size_t GetNextSet(size_t n) const { for (size_t i = (n + 1) / FlagsPerWord; i < NumWords; i++) { - Storage word = this->words[i]; + Storage word = m_words[i]; if (!util::IsAligned(n + 1, FlagsPerWord)) { word &= GetBitMask(n % FlagsPerWord) - 1; } diff --git a/libraries/libvapours/include/vapours/util/util_bitutil.hpp b/libraries/libvapours/include/vapours/util/util_bitutil.hpp index d8035065a..f7acd98e8 100644 --- a/libraries/libvapours/include/vapours/util/util_bitutil.hpp +++ b/libraries/libvapours/include/vapours/util/util_bitutil.hpp @@ -37,32 +37,32 @@ namespace ams::util { return __builtin_ctzll(static_cast(v)); } - T value; + T m_value; public: /* Note: GCC has a bug in constant-folding here. Workaround: wrap entire caller with constexpr. */ - constexpr ALWAYS_INLINE BitsOf(T value = T(0u)) : value(value) { + constexpr ALWAYS_INLINE BitsOf(T value = T(0u)) : m_value(value) { /* ... */ } constexpr ALWAYS_INLINE bool operator==(const BitsOf &other) const { - return this->value == other.value; + return m_value == other.m_value; } constexpr ALWAYS_INLINE bool operator!=(const BitsOf &other) const { - return this->value != other.value; + return m_value != other.m_value; } constexpr ALWAYS_INLINE int operator*() const { - return GetLsbPos(this->value); + return GetLsbPos(m_value); } constexpr ALWAYS_INLINE BitsOf &operator++() { - this->value &= ~(T(1u) << GetLsbPos(this->value)); + m_value &= ~(T(1u) << GetLsbPos(m_value)); return *this; } constexpr ALWAYS_INLINE BitsOf &operator++(int) { - BitsOf ret(this->value); + BitsOf ret(m_value); ++(*this); return ret; } diff --git a/libraries/libvapours/include/vapours/util/util_bounded_map.hpp b/libraries/libvapours/include/vapours/util/util_bounded_map.hpp index 7d39384bc..f09052319 100644 --- a/libraries/libvapours/include/vapours/util/util_bounded_map.hpp +++ b/libraries/libvapours/include/vapours/util/util_bounded_map.hpp @@ -24,20 +24,20 @@ namespace ams::util { template class BoundedMap { private: - std::array, N> keys; - std::array, N> values; + std::array, N> m_keys; + std::array, N> m_values; private: ALWAYS_INLINE void FreeEntry(size_t i) { - this->keys[i].reset(); - DestroyAt(this->values[i]); + m_keys[i].reset(); + DestroyAt(m_values[i]); } public: - constexpr BoundedMap() : keys(), values() { /* ... */ } + constexpr BoundedMap() : m_keys(), m_values() { /* ... */ } Value *Find(const Key &key) { for (size_t i = 0; i < N; i++) { - if (this->keys[i] && this->keys[i].value() == key) { - return GetPointer(this->values[i]); + if (m_keys[i] && m_keys[i].value() == key) { + return GetPointer(m_values[i]); } } return nullptr; @@ -45,7 +45,7 @@ namespace ams::util { void Remove(const Key &key) { for (size_t i = 0; i < N; i++) { - if (this->keys[i] && this->keys[i].value() == key) { + if (m_keys[i] && m_keys[i].value() == key) { this->FreeEntry(i); break; } @@ -60,7 +60,7 @@ namespace ams::util { bool IsFull() { for (size_t i = 0; i < N; i++) { - if (!this->keys[i]) { + if (!m_keys[i]) { return false; } } @@ -76,9 +76,9 @@ namespace ams::util { /* Find a free value. */ for (size_t i = 0; i < N; i++) { - if (!this->keys[i]) { - this->keys[i] = key; - ConstructAt(this->values[i], std::forward(value)); + if (!m_keys[i]) { + m_keys[i] = key; + ConstructAt(m_values[i], std::forward(value)); return true; } } @@ -89,17 +89,17 @@ namespace ams::util { bool InsertOrAssign(const Key &key, Value &&value) { /* Try to find and assign an existing value. */ for (size_t i = 0; i < N; i++) { - if (this->keys[i] && this->keys[i].value() == key) { - GetReference(this->values[i]) = std::forward(value); + if (m_keys[i] && m_keys[i].value() == key) { + GetReference(m_values[i]) = std::forward(value); return true; } } /* Find a free value. */ for (size_t i = 0; i < N; i++) { - if (!this->keys[i]) { - this->keys[i] = key; - ConstructAt(this->values[i], std::move(value)); + if (!m_keys[i]) { + m_keys[i] = key; + ConstructAt(m_values[i], std::move(value)); return true; } } @@ -116,9 +116,9 @@ namespace ams::util { /* Find a free value. */ for (size_t i = 0; i < N; i++) { - if (!this->keys[i]) { - this->keys[i] = key; - ConstructAt(this->values[i], std::forward(args)...); + if (!m_keys[i]) { + m_keys[i] = key; + ConstructAt(m_values[i], std::forward(args)...); return true; } } diff --git a/libraries/libvapours/include/vapours/util/util_fixed_tree.hpp b/libraries/libvapours/include/vapours/util/util_fixed_tree.hpp index f4826d37e..ead134c24 100644 --- a/libraries/libvapours/include/vapours/util/util_fixed_tree.hpp +++ b/libraries/libvapours/include/vapours/util/util_fixed_tree.hpp @@ -119,22 +119,22 @@ namespace ams::util { private: friend class ConstIterator; private: - const FixedTree *m_this; + const FixedTree *m_tree; int m_index; protected: - constexpr ALWAYS_INLINE IteratorBase(const FixedTree *tree, int index) : m_this(tree), m_index(index) { /* ... */ } + constexpr ALWAYS_INLINE IteratorBase(const FixedTree *tree, int index) : m_tree(tree), m_index(index) { /* ... */ } constexpr bool IsEqualImpl(const IteratorBase &rhs) const { /* Validate pre-conditions. */ - AMS_ASSERT(m_this); + AMS_ASSERT(m_tree); /* Check for tree equality. */ - if (m_this != rhs.m_this) { + if (m_tree != rhs.m_tree) { return false; } /* Check for nil. */ - if (m_this->IsNil(m_index) && m_this->IsNil(rhs.m_index)) { + if (m_tree->IsNil(m_index) && m_tree->IsNil(rhs.m_index)) { return true; } @@ -144,19 +144,19 @@ namespace ams::util { constexpr IteratorMember &DereferenceImpl() const { /* Validate pre-conditions. */ - AMS_ASSERT(m_this); + AMS_ASSERT(m_tree); - if (!m_this->IsNil(m_index)) { - return m_this->m_nodes[m_index].m_data; + if (!m_tree->IsNil(m_index)) { + return m_tree->m_nodes[m_index].m_data; } else { AMS_ASSERT(false); - return m_this->GetNode(std::numeric_limits::max())->m_data; + return m_tree->GetNode(std::numeric_limits::max())->m_data; } } constexpr ALWAYS_INLINE IteratorBase &IncrementImpl() { /* Validate pre-conditions. */ - AMS_ASSERT(m_this); + AMS_ASSERT(m_tree); this->OperateIndex(true); return *this; @@ -164,7 +164,7 @@ namespace ams::util { constexpr ALWAYS_INLINE IteratorBase &DecrementImpl() { /* Validate pre-conditions. */ - AMS_ASSERT(m_this); + AMS_ASSERT(m_tree); this->OperateIndex(false); return *this; @@ -176,18 +176,18 @@ namespace ams::util { if (m_index == Index_BeforeBegin) { m_index = 0; } else { - m_index = m_this->UncheckedPP(m_index); - if (m_this->IsNil(m_index)) { + m_index = m_tree->UncheckedPP(m_index); + if (m_tree->IsNil(m_index)) { m_index = Index_AfterEnd; } } } else { /* We're decrementing. */ if (m_index == Index_AfterEnd) { - m_index = static_cast(m_this->size()) - 1; + m_index = static_cast(m_tree->size()) - 1; } else { - m_index = m_this->UncheckedMM(m_index); - if (m_this->IsNil(m_index)) { + m_index = m_tree->UncheckedMM(m_index); + if (m_tree->IsNil(m_index)) { m_index = Index_BeforeBegin; } } @@ -233,7 +233,7 @@ namespace ams::util { constexpr ALWAYS_INLINE ConstIterator(const FixedTree &tree, int index) : IteratorBase(std::addressof(tree), index) { /* ... */ } constexpr ALWAYS_INLINE ConstIterator(const ConstIterator &rhs) = default; - constexpr ALWAYS_INLINE ConstIterator(const Iterator &rhs) : IteratorBase(rhs.m_this, rhs.m_index) { /* ... */ } + constexpr ALWAYS_INLINE ConstIterator(const Iterator &rhs) : IteratorBase(rhs.m_tree, rhs.m_index) { /* ... */ } constexpr ALWAYS_INLINE bool operator==(const ConstIterator &rhs) const { return this->IsEqualImpl(rhs); diff --git a/libraries/libvapours/include/vapours/util/util_intrusive_list.hpp b/libraries/libvapours/include/vapours/util/util_intrusive_list.hpp index f87ce0de1..5438d9dfe 100644 --- a/libraries/libvapours/include/vapours/util/util_intrusive_list.hpp +++ b/libraries/libvapours/include/vapours/util/util_intrusive_list.hpp @@ -36,13 +36,13 @@ namespace ams::util { private: friend class impl::IntrusiveListImpl; - IntrusiveListNode *prev; - IntrusiveListNode *next; + IntrusiveListNode *m_prev; + IntrusiveListNode *m_next; public: - constexpr ALWAYS_INLINE IntrusiveListNode() : prev(this), next(this) { /* ... */ } + constexpr ALWAYS_INLINE IntrusiveListNode() : m_prev(this), m_next(this) { /* ... */ } constexpr ALWAYS_INLINE bool IsLinked() const { - return this->next != this; + return m_next != this; } private: ALWAYS_INLINE void LinkPrev(IntrusiveListNode *node) { @@ -53,11 +53,11 @@ namespace ams::util { ALWAYS_INLINE void SplicePrev(IntrusiveListNode *first, IntrusiveListNode *last) { /* Splice a range into the list. */ - auto last_prev = last->prev; - first->prev = this->prev; - this->prev->next = first; - last_prev->next = this; - this->prev = last_prev; + auto last_prev = last->m_prev; + first->m_prev = m_prev; + last_prev->m_next = this; + m_prev->m_next = first; + m_prev = last_prev; } ALWAYS_INLINE void LinkNext(IntrusiveListNode *node) { @@ -68,40 +68,40 @@ namespace ams::util { ALWAYS_INLINE void SpliceNext(IntrusiveListNode *first, IntrusiveListNode *last) { /* Splice a range into the list. */ - auto last_prev = last->prev; - first->prev = this; - last_prev->next = next; - this->next->prev = last_prev; - this->next = first; + auto last_prev = last->m_prev; + first->m_prev = this; + last_prev->m_next = m_next; + m_next->m_prev = last_prev; + m_next = first; } ALWAYS_INLINE void Unlink() { - this->Unlink(this->next); + this->Unlink(m_next); } ALWAYS_INLINE void Unlink(IntrusiveListNode *last) { /* Unlink a node from a next node. */ - auto last_prev = last->prev; - this->prev->next = last; - last->prev = this->prev; - last_prev->next = this; - this->prev = last_prev; + auto last_prev = last->m_prev; + m_prev->m_next = last; + last->m_prev = m_prev; + last_prev->m_next = this; + m_prev = last_prev; } ALWAYS_INLINE IntrusiveListNode *GetPrev() { - return this->prev; + return m_prev; } ALWAYS_INLINE const IntrusiveListNode *GetPrev() const { - return this->prev; + return m_prev; } ALWAYS_INLINE IntrusiveListNode *GetNext() { - return this->next; + return m_next; } ALWAYS_INLINE const IntrusiveListNode *GetNext() const { - return this->next; + return m_next; } }; /* DEPRECATED: static_assert(std::is_literal_type::value); */ @@ -111,7 +111,7 @@ namespace ams::util { class IntrusiveListImpl { NON_COPYABLE(IntrusiveListImpl); private: - IntrusiveListNode root_node; + IntrusiveListNode m_root_node; public: template class Iterator; @@ -137,12 +137,12 @@ namespace ams::util { using pointer = typename std::conditional::type; using reference = typename std::conditional::type; private: - pointer node; + pointer m_node; public: - ALWAYS_INLINE explicit Iterator(pointer n) : node(n) { /* ... */ } + ALWAYS_INLINE explicit Iterator(pointer n) : m_node(n) { /* ... */ } ALWAYS_INLINE bool operator==(const Iterator &rhs) const { - return this->node == rhs.node; + return m_node == rhs.m_node; } ALWAYS_INLINE bool operator!=(const Iterator &rhs) const { @@ -150,20 +150,20 @@ namespace ams::util { } ALWAYS_INLINE pointer operator->() const { - return this->node; + return m_node; } ALWAYS_INLINE reference operator*() const { - return *this->node; + return *m_node; } ALWAYS_INLINE Iterator &operator++() { - this->node = this->node->next; + m_node = m_node->m_next; return *this; } ALWAYS_INLINE Iterator &operator--() { - this->node = this->node->prev; + m_node = m_node->m_prev; return *this; } @@ -180,31 +180,31 @@ namespace ams::util { } ALWAYS_INLINE operator Iterator() const { - return Iterator(this->node); + return Iterator(m_node); } ALWAYS_INLINE Iterator GetNonConstIterator() const { - return Iterator(const_cast(this->node)); + return Iterator(const_cast(m_node)); } }; public: - constexpr ALWAYS_INLINE IntrusiveListImpl() : root_node() { /* ... */ } + constexpr ALWAYS_INLINE IntrusiveListImpl() : m_root_node() { /* ... */ } /* Iterator accessors. */ ALWAYS_INLINE iterator begin() { - return iterator(this->root_node.GetNext()); + return iterator(m_root_node.GetNext()); } ALWAYS_INLINE const_iterator begin() const { - return const_iterator(this->root_node.GetNext()); + return const_iterator(m_root_node.GetNext()); } ALWAYS_INLINE iterator end() { - return iterator(std::addressof(this->root_node)); + return iterator(std::addressof(m_root_node)); } ALWAYS_INLINE const_iterator end() const { - return const_iterator(std::addressof(this->root_node)); + return const_iterator(std::addressof(m_root_node)); } ALWAYS_INLINE iterator iterator_to(reference v) { @@ -221,7 +221,7 @@ namespace ams::util { /* Content management. */ ALWAYS_INLINE bool empty() const { - return !this->root_node.IsLinked(); + return !m_root_node.IsLinked(); } ALWAYS_INLINE size_type size() const { @@ -229,35 +229,35 @@ namespace ams::util { } ALWAYS_INLINE reference back() { - return *this->root_node.GetPrev(); + return *m_root_node.GetPrev(); } ALWAYS_INLINE const_reference back() const { - return *this->root_node.GetPrev(); + return *m_root_node.GetPrev(); } ALWAYS_INLINE reference front() { - return *this->root_node.GetNext(); + return *m_root_node.GetNext(); } ALWAYS_INLINE const_reference front() const { - return *this->root_node.GetNext(); + return *m_root_node.GetNext(); } ALWAYS_INLINE void push_back(reference node) { - this->root_node.LinkPrev(std::addressof(node)); + m_root_node.LinkPrev(std::addressof(node)); } ALWAYS_INLINE void push_front(reference node) { - this->root_node.LinkNext(std::addressof(node)); + m_root_node.LinkNext(std::addressof(node)); } ALWAYS_INLINE void pop_back() { - this->root_node.GetPrev()->Unlink(); + m_root_node.GetPrev()->Unlink(); } ALWAYS_INLINE void pop_front() { - this->root_node.GetNext()->Unlink(); + m_root_node.GetNext()->Unlink(); } ALWAYS_INLINE iterator insert(const_iterator pos, reference node) { @@ -315,7 +315,7 @@ namespace ams::util { class IntrusiveList { NON_COPYABLE(IntrusiveList); private: - impl::IntrusiveListImpl impl; + impl::IntrusiveListImpl m_impl; public: template class Iterator; @@ -345,16 +345,16 @@ namespace ams::util { using pointer = typename std::conditional::type; using reference = typename std::conditional::type; private: - ImplIterator iterator; + ImplIterator m_iterator; private: - explicit ALWAYS_INLINE Iterator(ImplIterator it) : iterator(it) { /* ... */ } + explicit ALWAYS_INLINE Iterator(ImplIterator it) : m_iterator(it) { /* ... */ } ALWAYS_INLINE ImplIterator GetImplIterator() const { - return this->iterator; + return m_iterator; } public: ALWAYS_INLINE bool operator==(const Iterator &rhs) const { - return this->iterator == rhs.iterator; + return m_iterator == rhs.m_iterator; } ALWAYS_INLINE bool operator!=(const Iterator &rhs) const { @@ -362,37 +362,37 @@ namespace ams::util { } ALWAYS_INLINE pointer operator->() const { - return std::addressof(Traits::GetParent(*this->iterator)); + return std::addressof(Traits::GetParent(*m_iterator)); } ALWAYS_INLINE reference operator*() const { - return Traits::GetParent(*this->iterator); + return Traits::GetParent(*m_iterator); } ALWAYS_INLINE Iterator &operator++() { - ++this->iterator; + ++m_iterator; return *this; } ALWAYS_INLINE Iterator &operator--() { - --this->iterator; + --m_iterator; return *this; } ALWAYS_INLINE Iterator operator++(int) { const Iterator it{*this}; - ++this->iterator; + ++m_iterator; return it; } ALWAYS_INLINE Iterator operator--(int) { const Iterator it{*this}; - --this->iterator; + --m_iterator; return it; } ALWAYS_INLINE operator Iterator() const { - return Iterator(this->iterator); + return Iterator(m_iterator); } }; private: @@ -412,23 +412,23 @@ namespace ams::util { return Traits::GetParent(node); } public: - constexpr ALWAYS_INLINE IntrusiveList() : impl() { /* ... */ } + constexpr ALWAYS_INLINE IntrusiveList() : m_impl() { /* ... */ } /* Iterator accessors. */ ALWAYS_INLINE iterator begin() { - return iterator(this->impl.begin()); + return iterator(m_impl.begin()); } ALWAYS_INLINE const_iterator begin() const { - return const_iterator(this->impl.begin()); + return const_iterator(m_impl.begin()); } ALWAYS_INLINE iterator end() { - return iterator(this->impl.end()); + return iterator(m_impl.end()); } ALWAYS_INLINE const_iterator end() const { - return const_iterator(this->impl.end()); + return const_iterator(m_impl.end()); } ALWAYS_INLINE const_iterator cbegin() const { @@ -464,82 +464,82 @@ namespace ams::util { } ALWAYS_INLINE iterator iterator_to(reference v) { - return iterator(this->impl.iterator_to(GetNode(v))); + return iterator(m_impl.iterator_to(GetNode(v))); } ALWAYS_INLINE const_iterator iterator_to(const_reference v) const { - return const_iterator(this->impl.iterator_to(GetNode(v))); + return const_iterator(m_impl.iterator_to(GetNode(v))); } /* Content management. */ ALWAYS_INLINE bool empty() const { - return this->impl.empty(); + return m_impl.empty(); } ALWAYS_INLINE size_type size() const { - return this->impl.size(); + return m_impl.size(); } ALWAYS_INLINE reference back() { - AMS_ASSERT(!this->impl.empty()); - return GetParent(this->impl.back()); + AMS_ASSERT(!m_impl.empty()); + return GetParent(m_impl.back()); } ALWAYS_INLINE const_reference back() const { - AMS_ASSERT(!this->impl.empty()); - return GetParent(this->impl.back()); + AMS_ASSERT(!m_impl.empty()); + return GetParent(m_impl.back()); } ALWAYS_INLINE reference front() { - AMS_ASSERT(!this->impl.empty()); - return GetParent(this->impl.front()); + AMS_ASSERT(!m_impl.empty()); + return GetParent(m_impl.front()); } ALWAYS_INLINE const_reference front() const { - AMS_ASSERT(!this->impl.empty()); - return GetParent(this->impl.front()); + AMS_ASSERT(!m_impl.empty()); + return GetParent(m_impl.front()); } ALWAYS_INLINE void push_back(reference ref) { - this->impl.push_back(GetNode(ref)); + m_impl.push_back(GetNode(ref)); } ALWAYS_INLINE void push_front(reference ref) { - this->impl.push_front(GetNode(ref)); + m_impl.push_front(GetNode(ref)); } ALWAYS_INLINE void pop_back() { - AMS_ASSERT(!this->impl.empty()); - this->impl.pop_back(); + AMS_ASSERT(!m_impl.empty()); + m_impl.pop_back(); } ALWAYS_INLINE void pop_front() { - AMS_ASSERT(!this->impl.empty()); - this->impl.pop_front(); + AMS_ASSERT(!m_impl.empty()); + m_impl.pop_front(); } ALWAYS_INLINE iterator insert(const_iterator pos, reference ref) { - return iterator(this->impl.insert(pos.GetImplIterator(), GetNode(ref))); + return iterator(m_impl.insert(pos.GetImplIterator(), GetNode(ref))); } ALWAYS_INLINE void splice(const_iterator pos, IntrusiveList &o) { - this->impl.splice(pos.GetImplIterator(), o.impl); + m_impl.splice(pos.GetImplIterator(), o.m_impl); } ALWAYS_INLINE void splice(const_iterator pos, IntrusiveList &o, const_iterator first) { - this->impl.splice(pos.GetImplIterator(), o.impl, first.GetImplIterator()); + m_impl.splice(pos.GetImplIterator(), o.m_impl, first.GetImplIterator()); } ALWAYS_INLINE void splice(const_iterator pos, IntrusiveList &o, const_iterator first, const_iterator last) { - this->impl.splice(pos.GetImplIterator(), o.impl, first.GetImplIterator(), last.GetImplIterator()); + m_impl.splice(pos.GetImplIterator(), o.m_impl, first.GetImplIterator(), last.GetImplIterator()); } ALWAYS_INLINE iterator erase(const_iterator pos) { - return iterator(this->impl.erase(pos.GetImplIterator())); + return iterator(m_impl.erase(pos.GetImplIterator())); } ALWAYS_INLINE void clear() { - this->impl.clear(); + m_impl.clear(); } }; diff --git a/libraries/libvapours/include/vapours/util/util_tinymt.hpp b/libraries/libvapours/include/vapours/util/util_tinymt.hpp index 94c1adf28..2fe771ade 100644 --- a/libraries/libvapours/include/vapours/util/util_tinymt.hpp +++ b/libraries/libvapours/include/vapours/util/util_tinymt.hpp @@ -51,20 +51,20 @@ namespace ams::util { return value ^ (value >> 30); } private: - State state; + State m_state; private: /* Internal API. */ void FinalizeInitialization() { - const u32 state0 = this->state.data[0] & TopBitmask; - const u32 state1 = this->state.data[1]; - const u32 state2 = this->state.data[2]; - const u32 state3 = this->state.data[3]; + const u32 state0 = m_state.data[0] & TopBitmask; + const u32 state1 = m_state.data[1]; + const u32 state2 = m_state.data[2]; + const u32 state3 = m_state.data[3]; if (state0 == 0 && state1 == 0 && state2 == 0 && state3 == 0) { - this->state.data[0] = 'T'; - this->state.data[1] = 'I'; - this->state.data[2] = 'N'; - this->state.data[3] = 'Y'; + m_state.data[0] = 'T'; + m_state.data[1] = 'I'; + m_state.data[2] = 'N'; + m_state.data[3] = 'Y'; } for (int i = 0; i < NumDiscardedInitOutputs; i++) { @@ -102,42 +102,42 @@ namespace ams::util { state2 ^= y; } public: - constexpr TinyMT() : state() { /* ... */ } + constexpr TinyMT() : m_state() { /* ... */ } /* Public API. */ /* Initialization. */ void Initialize(u32 seed) { - this->state.data[0] = seed; - this->state.data[1] = ParamMat1; - this->state.data[2] = ParamMat2; - this->state.data[3] = ParamTmat; + m_state.data[0] = seed; + m_state.data[1] = ParamMat1; + m_state.data[2] = ParamMat2; + m_state.data[3] = ParamTmat; for (int i = 1; i < MinimumInitIterations; i++) { - const u32 mixed = XorByShifted30(this->state.data[(i - 1) % NumStateWords]); - this->state.data[i % NumStateWords] ^= mixed * ParamMult + i; + const u32 mixed = XorByShifted30(m_state.data[(i - 1) % NumStateWords]); + m_state.data[i % NumStateWords] ^= mixed * ParamMult + i; } this->FinalizeInitialization(); } void Initialize(const u32 *seed, int seed_count) { - this->state.data[0] = 0; - this->state.data[1] = ParamMat1; - this->state.data[2] = ParamMat2; - this->state.data[3] = ParamTmat; + m_state.data[0] = 0; + m_state.data[1] = ParamMat1; + m_state.data[2] = ParamMat2; + m_state.data[3] = ParamTmat; { const int num_init_iterations = std::max(seed_count + 1, MinimumInitIterations) - 1; - GenerateInitialValuePlus(std::addressof(this->state), 0, seed_count); + GenerateInitialValuePlus(std::addressof(m_state), 0, seed_count); for (int i = 0; i < num_init_iterations; i++) { - GenerateInitialValuePlus(std::addressof(this->state), (i + 1) % NumStateWords, (i < seed_count) ? seed[i] : 0); + GenerateInitialValuePlus(std::addressof(m_state), (i + 1) % NumStateWords, (i < seed_count) ? seed[i] : 0); } for (int i = 0; i < static_cast(NumStateWords); i++) { - GenerateInitialValueXor(std::addressof(this->state), (i + 1 + num_init_iterations) % NumStateWords); + GenerateInitialValueXor(std::addressof(m_state), (i + 1 + num_init_iterations) % NumStateWords); } } @@ -146,11 +146,11 @@ namespace ams::util { /* State management. */ void GetState(TinyMT::State *out) const { - std::memcpy(out->data, this->state.data, sizeof(this->state)); + std::memcpy(out->data, m_state.data, sizeof(m_state)); } void SetState(const TinyMT::State *state) { - std::memcpy(this->state.data, state->data, sizeof(this->state)); + std::memcpy(m_state.data, state->data, sizeof(m_state)); } /* Random generation. */ @@ -185,13 +185,13 @@ namespace ams::util { NOINLINE u32 GenerateRandomU32() { /* Advance state. */ - const u32 x0 = (this->state.data[0] & TopBitmask) ^ this->state.data[1] ^ this->state.data[2]; - const u32 y0 = this->state.data[3]; + const u32 x0 = (m_state.data[0] & TopBitmask) ^ m_state.data[1] ^ m_state.data[2]; + const u32 y0 = m_state.data[3]; const u32 x1 = x0 ^ (x0 << 1); const u32 y1 = y0 ^ (y0 >> 1) ^ x1; - const u32 state0 = this->state.data[1]; - u32 state1 = this->state.data[2]; + const u32 state0 = m_state.data[1]; + u32 state1 = m_state.data[2]; u32 state2 = x1 ^ (y1 << 10); const u32 state3 = y1; @@ -200,10 +200,10 @@ namespace ams::util { state2 ^= ParamMat2; } - this->state.data[0] = state0; - this->state.data[1] = state1; - this->state.data[2] = state2; - this->state.data[3] = state3; + m_state.data[0] = state0; + m_state.data[1] = state1; + m_state.data[2] = state2; + m_state.data[3] = state3; /* Temper. */ const u32 t1 = state0 + (state2 >> 8); diff --git a/libraries/libvapours/source/crypto/impl/crypto_aes_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_aes_impl.arch.arm64.cpp index 1e93da23b..24bc8782c 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_aes_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_aes_impl.arch.arm64.cpp @@ -40,16 +40,16 @@ namespace ams::crypto::impl { if constexpr (KeySize == 16) { /* Aes 128. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes128Context)); - aes128ContextCreate(reinterpret_cast(this->round_keys), key, is_encrypt); + static_assert(sizeof(m_round_keys) == sizeof(::Aes128Context)); + aes128ContextCreate(reinterpret_cast(m_round_keys), key, is_encrypt); } else if constexpr (KeySize == 24) { /* Aes 192. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes192Context)); - aes192ContextCreate(reinterpret_cast(this->round_keys), key, is_encrypt); + static_assert(sizeof(m_round_keys) == sizeof(::Aes192Context)); + aes192ContextCreate(reinterpret_cast(m_round_keys), key, is_encrypt); } else if constexpr (KeySize == 32) { /* Aes 256. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes256Context)); - aes256ContextCreate(reinterpret_cast(this->round_keys), key, is_encrypt); + static_assert(sizeof(m_round_keys) == sizeof(::Aes256Context)); + aes256ContextCreate(reinterpret_cast(m_round_keys), key, is_encrypt); } else { /* Invalid key size. */ static_assert(!std::is_same, AesImpl>::value); @@ -65,16 +65,16 @@ namespace ams::crypto::impl { if constexpr (KeySize == 16) { /* Aes 128. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes128Context)); - aes128EncryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes128Context)); + aes128EncryptBlock(reinterpret_cast(m_round_keys), dst, src); } else if constexpr (KeySize == 24) { /* Aes 192. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes192Context)); - aes192EncryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes192Context)); + aes192EncryptBlock(reinterpret_cast(m_round_keys), dst, src); } else if constexpr (KeySize == 32) { /* Aes 256. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes256Context)); - aes256EncryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes256Context)); + aes256EncryptBlock(reinterpret_cast(m_round_keys), dst, src); } else { /* Invalid key size. */ static_assert(!std::is_same, AesImpl>::value); @@ -90,16 +90,16 @@ namespace ams::crypto::impl { if constexpr (KeySize == 16) { /* Aes 128. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes128Context)); - aes128DecryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes128Context)); + aes128DecryptBlock(reinterpret_cast(m_round_keys), dst, src); } else if constexpr (KeySize == 24) { /* Aes 192. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes192Context)); - aes192DecryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes192Context)); + aes192DecryptBlock(reinterpret_cast(m_round_keys), dst, src); } else if constexpr (KeySize == 32) { /* Aes 256. */ - static_assert(sizeof(this->round_keys) == sizeof(::Aes256Context)); - aes256DecryptBlock(reinterpret_cast(this->round_keys), dst, src); + static_assert(sizeof(m_round_keys) == sizeof(::Aes256Context)); + aes256DecryptBlock(reinterpret_cast(m_round_keys), dst, src); } else { /* Invalid key size. */ static_assert(!std::is_same, AesImpl>::value); diff --git a/libraries/libvapours/source/crypto/impl/crypto_bignum.cpp b/libraries/libvapours/source/crypto/impl/crypto_bignum.cpp index 527494d15..805c30c94 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_bignum.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_bignum.cpp @@ -54,13 +54,13 @@ namespace ams::crypto::impl { } size_t BigNum::GetSize() const { - if (this->num_words == 0) { + if (m_num_words == 0) { return 0; } static_assert(sizeof(Word) == 4); - size_t size = this->num_words * sizeof(Word); - const Word last = this->words[this->num_words - 1]; + size_t size = m_num_words * sizeof(Word); + const Word last = m_words[m_num_words - 1]; AMS_ASSERT(last != 0); if (last >= 0x01000000u) { return size - 0; @@ -84,21 +84,21 @@ namespace ams::crypto::impl { } /* Ensure we have space for the number. */ - AMS_ASSERT(src_size <= this->max_words * sizeof(Word)); - if (AMS_UNLIKELY(!(src_size <= this->max_words * sizeof(Word)))) { + AMS_ASSERT(src_size <= m_max_words * sizeof(Word)); + if (AMS_UNLIKELY(!(src_size <= m_max_words * sizeof(Word)))) { return false; } /* Import. */ - this->num_words = util::AlignUp(src_size, sizeof(Word)) / sizeof(Word); + m_num_words = util::AlignUp(src_size, sizeof(Word)) / sizeof(Word); - ImportImpl(this->words, this->max_words, data, src_size); + ImportImpl(m_words, m_max_words, data, src_size); return true; } void BigNum::Export(void *dst, size_t dst_size) { AMS_ASSERT(dst_size >= this->GetSize()); - ExportImpl(static_cast(dst), dst_size, this->words, this->num_words); + ExportImpl(static_cast(dst), dst_size, m_words, m_num_words); } bool BigNum::ExpMod(void *dst, const void *src, size_t size, const BigNum &exp, u32 *work_buf, size_t work_buf_size) const { @@ -126,7 +126,7 @@ namespace ams::crypto::impl { } /* Perform the exponentiation. */ - if (!ExpMod(signature.words, signature.words, exp.words, exp.num_words, this->words, this->num_words, std::addressof(allocator))) { + if (!ExpMod(signature.m_words, signature.m_words, exp.m_words, exp.m_num_words, m_words, m_num_words, std::addressof(allocator))) { return false; } @@ -138,11 +138,11 @@ namespace ams::crypto::impl { } void BigNum::ClearToZero() { - std::memset(this->words, 0, this->num_words * sizeof(Word)); + std::memset(m_words, 0, m_num_words * sizeof(Word)); } void BigNum::UpdateCount() { - this->num_words = CountWords(this->words, this->max_words); + m_num_words = CountWords(m_words, m_max_words); } } \ No newline at end of file diff --git a/libraries/libvapours/source/crypto/impl/crypto_ctr_mode_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_ctr_mode_impl.arch.arm64.cpp index af0da88fa..6b171967d 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_ctr_mode_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_ctr_mode_impl.arch.arm64.cpp @@ -89,7 +89,7 @@ namespace ams::crypto::impl { template<> void CtrModeImpl::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks) { /* Preload all round keys + iv into neon registers. */ - const u8 *keys = this->block_cipher->GetRoundKey(); + const u8 *keys = m_block_cipher->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -101,7 +101,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(8); DECLARE_ROUND_KEY_VAR(9); DECLARE_ROUND_KEY_VAR(10); - uint8x16_t ctr0 = vld1q_u8(this->counter); + uint8x16_t ctr0 = vld1q_u8(m_counter); uint64_t high, low; /* Process three blocks at a time, when possible. */ @@ -237,13 +237,13 @@ namespace ams::crypto::impl { num_blocks--; } - vst1q_u8(this->counter, ctr0); + vst1q_u8(m_counter, ctr0); } template<> void CtrModeImpl::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks) { /* Preload all round keys + iv into neon registers. */ - const u8 *keys = this->block_cipher->GetRoundKey(); + const u8 *keys = m_block_cipher->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -257,7 +257,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(10); DECLARE_ROUND_KEY_VAR(11); DECLARE_ROUND_KEY_VAR(12); - uint8x16_t ctr0 = vld1q_u8(this->counter); + uint8x16_t ctr0 = vld1q_u8(m_counter); uint64_t high, low; /* Process three blocks at a time, when possible. */ @@ -401,13 +401,13 @@ namespace ams::crypto::impl { num_blocks--; } - vst1q_u8(this->counter, ctr0); + vst1q_u8(m_counter, ctr0); } template<> void CtrModeImpl::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks) { /* Preload all round keys + iv into neon registers. */ - const u8 *keys = this->block_cipher->GetRoundKey(); + const u8 *keys = m_block_cipher->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -423,7 +423,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(12); DECLARE_ROUND_KEY_VAR(13); DECLARE_ROUND_KEY_VAR(14); - uint8x16_t ctr0 = vld1q_u8(this->counter); + uint8x16_t ctr0 = vld1q_u8(m_counter); uint64_t high, low; /* Process three blocks at a time, when possible. */ @@ -576,7 +576,7 @@ namespace ams::crypto::impl { num_blocks--; } - vst1q_u8(this->counter, ctr0); + vst1q_u8(m_counter, ctr0); } } diff --git a/libraries/libvapours/source/crypto/impl/crypto_gcm_mode_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_gcm_mode_impl.arch.arm64.cpp index b7d675a95..e7086b049 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_gcm_mode_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_gcm_mode_impl.arch.arm64.cpp @@ -108,96 +108,96 @@ namespace ams::crypto::impl { template void GcmModeImpl::Initialize(const BlockCipher *block_cipher) { /* Set member variables. */ - this->block_cipher = block_cipher; - this->cipher_func = std::addressof(GcmModeImpl::ProcessBlock); + m_block_cipher = block_cipher; + m_cipher_func = std::addressof(GcmModeImpl::ProcessBlock); /* Pre-calculate values to speed up galois field multiplications later. */ this->InitializeHashKey(); /* Note that we're initialized. */ - this->state = State_Initialized; + m_state = State_Initialized; } template void GcmModeImpl::Reset(const void *iv, size_t iv_size) { /* Validate pre-conditions. */ - AMS_ASSERT(this->state >= State_Initialized); + AMS_ASSERT(m_state >= State_Initialized); /* Reset blocks. */ - this->block_x.block_128.Clear(); - this->block_tmp.block_128.Clear(); + m_block_x.block_128.Clear(); + m_block_tmp.block_128.Clear(); /* Clear sizes. */ - this->aad_size = 0; - this->msg_size = 0; - this->aad_remaining = 0; - this->msg_remaining = 0; + m_aad_size = 0; + m_msg_size = 0; + m_aad_remaining = 0; + m_msg_remaining = 0; /* Update our state. */ - this->state = State_ProcessingAad; + m_state = State_ProcessingAad; /* Set our iv. */ if (iv_size == 12) { /* If our iv is the correct size, simply copy in the iv, and set the magic bit. */ - std::memcpy(std::addressof(this->block_ek0), iv, iv_size); - util::StoreBigEndian(this->block_ek0.block_32 + 3, static_cast(1)); + std::memcpy(std::addressof(m_block_ek0), iv, iv_size); + util::StoreBigEndian(m_block_ek0.block_32 + 3, static_cast(1)); } else { /* Clear our ek0 block. */ - this->block_ek0.block_128.Clear(); + m_block_ek0.block_128.Clear(); /* Update using the iv as aad. */ this->UpdateAad(iv, iv_size); /* Treat the iv as fake msg for the mac that will become our iv. */ - this->msg_size = this->aad_size; - this->aad_size = 0; + m_msg_size = m_aad_size; + m_aad_size = 0; /* Compute a non-final mac. */ this->ComputeMac(false); /* Set our ek0 block to our calculated mac block. */ - this->block_ek0 = this->block_x; + m_block_ek0 = m_block_x; /* Clear our calculated mac block. */ - this->block_x.block_128.Clear(); + m_block_x.block_128.Clear(); /* Reset our state. */ - this->msg_size = 0; - this->aad_size = 0; - this->msg_remaining = 0; - this->aad_remaining = 0; + m_msg_size = 0; + m_aad_size = 0; + m_msg_remaining = 0; + m_aad_remaining = 0; } /* Set the working block to the iv. */ - this->block_ek = this->block_ek0; + m_block_ek = m_block_ek0; } template void GcmModeImpl::UpdateAad(const void *aad, size_t aad_size) { /* Validate pre-conditions. */ - AMS_ASSERT(this->state == State_ProcessingAad); - AMS_ASSERT(this->msg_size == 0); + AMS_ASSERT(m_state == State_ProcessingAad); + AMS_ASSERT(m_msg_size == 0); /* Update our aad size. */ - this->aad_size += aad_size; + m_aad_size += aad_size; /* Define a working tracker variable. */ const u8 *cur_aad = static_cast(aad); /* Process any leftover aad data from a previous invocation. */ - if (this->aad_remaining > 0) { + if (m_aad_remaining > 0) { while (aad_size > 0) { /* Copy in a byte of the aad to our partial block. */ - this->block_x.block_8[this->aad_remaining] ^= *(cur_aad++); + m_block_x.block_8[m_aad_remaining] ^= *(cur_aad++); /* Note that we consumed a byte. */ --aad_size; /* Increment our partial block size. */ - this->aad_remaining = (this->aad_remaining + 1) % BlockSize; + m_aad_remaining = (m_aad_remaining + 1) % BlockSize; /* If we have a complete block, process it and move onward. */ - GaloisFieldMult(std::addressof(this->block_x), std::addressof(this->block_x), std::addressof(this->h_mult_blocks[0])); + GaloisFieldMult(std::addressof(m_block_x), std::addressof(m_block_x), std::addressof(m_h_mult_blocks[0])); } } @@ -205,11 +205,11 @@ namespace ams::crypto::impl { while (aad_size >= BlockSize) { /* Xor the current aad into our work block. */ for (size_t i = 0; i < BlockSize; ++i) { - this->block_x.block_8[i] ^= *(cur_aad++); + m_block_x.block_8[i] ^= *(cur_aad++); } /* Multiply the blocks in our galois field. */ - GaloisFieldMult(std::addressof(this->block_x), std::addressof(this->block_x), std::addressof(this->h_mult_blocks[0])); + GaloisFieldMult(std::addressof(m_block_x), std::addressof(m_block_x), std::addressof(m_h_mult_blocks[0])); /* Note that we've processed a block. */ aad_size -= BlockSize; @@ -218,11 +218,11 @@ namespace ams::crypto::impl { /* Update our state with whatever aad is left over. */ if (aad_size > 0) { /* Note how much left over data we have. */ - this->aad_remaining = static_cast(aad_size); + m_aad_remaining = static_cast(aad_size); /* Xor the data in. */ for (size_t i = 0; i < aad_size; ++i) { - this->block_x.block_8[i] ^= *(cur_aad++); + m_block_x.block_8[i] ^= *(cur_aad++); } } } @@ -234,21 +234,21 @@ namespace ams::crypto::impl { template void GcmModeImpl::GetMac(void *dst, size_t dst_size) { /* Validate pre-conditions. */ - AMS_ASSERT(State_ProcessingAad <= this->state && this->state <= State_Done); + AMS_ASSERT(State_ProcessingAad <= m_state && m_state <= State_Done); AMS_ASSERT(dst != nullptr); AMS_ASSERT(dst_size >= MacSize); - AMS_ASSERT(this->aad_remaining == 0); - AMS_ASSERT(this->msg_remaining == 0); + AMS_ASSERT(m_aad_remaining == 0); + AMS_ASSERT(m_msg_remaining == 0); AMS_UNUSED(dst_size); /* If we haven't already done so, compute the final mac. */ - if (this->state != State_Done) { + if (m_state != State_Done) { this->ComputeMac(true); - this->state = State_Done; + m_state = State_Done; } - static_assert(sizeof(this->block_x) == MacSize); - std::memcpy(dst, std::addressof(this->block_x), MacSize); + static_assert(sizeof(m_block_x) == MacSize); + std::memcpy(dst, std::addressof(m_block_x), MacSize); } template @@ -258,18 +258,18 @@ namespace ams::crypto::impl { /* to speed up galois field arithmetic. */ constexpr const Block EmptyBlock = {}; - this->ProcessBlock(std::addressof(this->h_mult_blocks[0]), std::addressof(EmptyBlock), this->block_cipher); + this->ProcessBlock(std::addressof(m_h_mult_blocks[0]), std::addressof(EmptyBlock), m_block_cipher); } template void GcmModeImpl::ComputeMac(bool encrypt) { /* If we have leftover data, process it. */ - if (this->aad_remaining > 0 || this->msg_remaining > 0) { - GaloisFieldMult(std::addressof(this->block_x), std::addressof(this->block_x), std::addressof(this->h_mult_blocks[0])); + if (m_aad_remaining > 0 || m_msg_remaining > 0) { + GaloisFieldMult(std::addressof(m_block_x), std::addressof(m_block_x), std::addressof(m_h_mult_blocks[0])); } /* Setup the last block. */ - Block last_block = Block{ .block_128 = { this->msg_size, this->aad_size } }; + Block last_block = Block{ .block_128 = { m_msg_size, m_aad_size } }; /* Multiply the last block by 8 to account for bit vs byte sizes. */ static_assert(offsetof(Block128, hi) == 0); @@ -279,21 +279,21 @@ namespace ams::crypto::impl { /* Xor the data in. */ for (size_t i = 0; i < BlockSize; ++i) { - this->block_x.block_8[BlockSize - 1 - i] ^= last_block.block_8[i]; + m_block_x.block_8[BlockSize - 1 - i] ^= last_block.block_8[i]; } /* Perform the final multiplication. */ - GaloisFieldMult(std::addressof(this->block_x), std::addressof(this->block_x), std::addressof(this->h_mult_blocks[0])); + GaloisFieldMult(std::addressof(m_block_x), std::addressof(m_block_x), std::addressof(m_h_mult_blocks[0])); /* If we need to do an encryption, do so. */ if (encrypt) { /* Encrypt the iv. */ u8 enc_result[BlockSize]; - this->ProcessBlock(enc_result, std::addressof(this->block_ek0), this->block_cipher); + this->ProcessBlock(enc_result, std::addressof(m_block_ek0), m_block_cipher); /* Xor the iv in. */ for (size_t i = 0; i < BlockSize; ++i) { - this->block_x.block_8[i] ^= enc_result[i]; + m_block_x.block_8[i] ^= enc_result[i]; } } } diff --git a/libraries/libvapours/source/crypto/impl/crypto_sha1_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_sha1_impl.arch.arm64.cpp index 5f6b16517..e01c9132d 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_sha1_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_sha1_impl.arch.arm64.cpp @@ -20,20 +20,20 @@ namespace ams::crypto::impl { #ifdef ATMOSPHERE_IS_STRATOSPHERE void Sha1Impl::Initialize() { - static_assert(sizeof(this->state) == sizeof(::Sha1Context)); - ::sha1ContextCreate(reinterpret_cast<::Sha1Context *>(std::addressof(this->state))); + static_assert(sizeof(m_state) == sizeof(::Sha1Context)); + ::sha1ContextCreate(reinterpret_cast<::Sha1Context *>(std::addressof(m_state))); } void Sha1Impl::Update(const void *data, size_t size) { - static_assert(sizeof(this->state) == sizeof(::Sha1Context)); - ::sha1ContextUpdate(reinterpret_cast<::Sha1Context *>(std::addressof(this->state)), data, size); + static_assert(sizeof(m_state) == sizeof(::Sha1Context)); + ::sha1ContextUpdate(reinterpret_cast<::Sha1Context *>(std::addressof(m_state)), data, size); } void Sha1Impl::GetHash(void *dst, size_t size) { - static_assert(sizeof(this->state) == sizeof(::Sha1Context)); + static_assert(sizeof(m_state) == sizeof(::Sha1Context)); AMS_ASSERT(size >= HashSize); AMS_UNUSED(size); - ::sha1ContextGetHash(reinterpret_cast<::Sha1Context *>(std::addressof(this->state)), dst); + ::sha1ContextGetHash(reinterpret_cast<::Sha1Context *>(std::addressof(m_state)), dst); } #else diff --git a/libraries/libvapours/source/crypto/impl/crypto_sha256_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_sha256_impl.arch.arm64.cpp index b0c4e6cb9..6235dd037 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_sha256_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_sha256_impl.arch.arm64.cpp @@ -20,42 +20,42 @@ namespace ams::crypto::impl { #ifdef ATMOSPHERE_IS_STRATOSPHERE void Sha256Impl::Initialize() { - static_assert(sizeof(this->state) == sizeof(::Sha256Context)); - ::sha256ContextCreate(reinterpret_cast<::Sha256Context *>(std::addressof(this->state))); + static_assert(sizeof(m_state) == sizeof(::Sha256Context)); + ::sha256ContextCreate(reinterpret_cast<::Sha256Context *>(std::addressof(m_state))); } void Sha256Impl::Update(const void *data, size_t size) { - static_assert(sizeof(this->state) == sizeof(::Sha256Context)); - ::sha256ContextUpdate(reinterpret_cast<::Sha256Context *>(std::addressof(this->state)), data, size); + static_assert(sizeof(m_state) == sizeof(::Sha256Context)); + ::sha256ContextUpdate(reinterpret_cast<::Sha256Context *>(std::addressof(m_state)), data, size); } void Sha256Impl::GetHash(void *dst, size_t size) { - static_assert(sizeof(this->state) == sizeof(::Sha256Context)); + static_assert(sizeof(m_state) == sizeof(::Sha256Context)); AMS_ASSERT(size >= HashSize); AMS_UNUSED(size); - ::sha256ContextGetHash(reinterpret_cast<::Sha256Context *>(std::addressof(this->state)), dst); + ::sha256ContextGetHash(reinterpret_cast<::Sha256Context *>(std::addressof(m_state)), dst); } void Sha256Impl::InitializeWithContext(const Sha256Context *context) { - static_assert(sizeof(this->state) == sizeof(::Sha256Context)); + static_assert(sizeof(m_state) == sizeof(::Sha256Context)); /* Copy state in from the context. */ - std::memcpy(this->state.intermediate_hash, context->intermediate_hash, sizeof(this->state.intermediate_hash)); - this->state.bits_consumed = context->bits_consumed; + std::memcpy(m_state.intermediate_hash, context->intermediate_hash, sizeof(m_state.intermediate_hash)); + m_state.bits_consumed = context->bits_consumed; /* Clear the rest of state. */ - std::memset(this->state.buffer, 0, sizeof(this->state.buffer)); - this->state.num_buffered = 0; - this->state.finalized = false; + std::memset(m_state.buffer, 0, sizeof(m_state.buffer)); + m_state.num_buffered = 0; + m_state.finalized = false; } size_t Sha256Impl::GetContext(Sha256Context *context) const { - static_assert(sizeof(this->state) == sizeof(::Sha256Context)); - std::memcpy(context->intermediate_hash, this->state.intermediate_hash, sizeof(context->intermediate_hash)); - context->bits_consumed = this->state.bits_consumed; + static_assert(sizeof(m_state) == sizeof(::Sha256Context)); + std::memcpy(context->intermediate_hash, m_state.intermediate_hash, sizeof(context->intermediate_hash)); + context->bits_consumed = m_state.bits_consumed; - return this->state.num_buffered; + return m_state.num_buffered; } #else diff --git a/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.arch.arm64.cpp b/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.arch.arm64.cpp index f633554dc..bb2306de5 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.arch.arm64.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.arch.arm64.cpp @@ -110,7 +110,7 @@ namespace ams::crypto::impl { } size_t XtsModeImpl::UpdateGeneric(void *dst, size_t dst_size, const void *src, size_t src_size) { - AMS_ASSERT(this->state == State_Initialized || this->state == State_Processing); + AMS_ASSERT(m_state == State_Initialized || m_state == State_Processing); return UpdateImpl(this, dst, dst_size, src, src_size); } @@ -118,13 +118,13 @@ namespace ams::crypto::impl { size_t XtsModeImpl::ProcessBlocksGeneric(u8 *dst, const u8 *src, size_t num_blocks) { size_t processed = BlockSize * (num_blocks - 1); - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } - uint8x16_t tweak = vld1q_u8(this->tweak); + uint8x16_t tweak = vld1q_u8(m_tweak); while ((--num_blocks) > 0) { /* Xor */ @@ -134,7 +134,7 @@ namespace ams::crypto::impl { /* Encrypt */ vst1q_u8(dst, block); - this->cipher_func(dst, dst, this->cipher_ctx); + m_cipher_func(dst, dst, m_cipher_ctx); block = vld1q_u8(dst); /* Xor */ @@ -146,11 +146,11 @@ namespace ams::crypto::impl { tweak = MultiplyTweak(tweak); } - vst1q_u8(this->tweak, tweak); + vst1q_u8(m_tweak, tweak); - std::memcpy(this->last_block, src, BlockSize); + std::memcpy(m_last_block, src, BlockSize); - this->state = State_Processing; + m_state = State_Processing; return processed; } @@ -168,14 +168,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -187,7 +187,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(8); DECLARE_ROUND_KEY_VAR(9); DECLARE_ROUND_KEY_VAR(10); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -314,10 +314,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } @@ -327,14 +327,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -348,7 +348,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(10); DECLARE_ROUND_KEY_VAR(11); DECLARE_ROUND_KEY_VAR(12); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -483,10 +483,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } @@ -496,14 +496,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -519,7 +519,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(12); DECLARE_ROUND_KEY_VAR(13); DECLARE_ROUND_KEY_VAR(14); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -663,10 +663,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } @@ -676,14 +676,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -695,7 +695,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(8); DECLARE_ROUND_KEY_VAR(9); DECLARE_ROUND_KEY_VAR(10); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -822,10 +822,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } @@ -835,14 +835,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -856,7 +856,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(10); DECLARE_ROUND_KEY_VAR(11); DECLARE_ROUND_KEY_VAR(12); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -991,10 +991,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } @@ -1004,14 +1004,14 @@ namespace ams::crypto::impl { /* Handle last buffered block. */ size_t processed = (num_blocks - 1) * BlockSize; - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); dst += BlockSize; processed += BlockSize; } /* Preload all round keys + iv into neon registers. */ - const u8 *keys = static_cast(this->cipher_ctx)->GetRoundKey(); + const u8 *keys = static_cast(m_cipher_ctx)->GetRoundKey(); DECLARE_ROUND_KEY_VAR(0); DECLARE_ROUND_KEY_VAR(1); DECLARE_ROUND_KEY_VAR(2); @@ -1027,7 +1027,7 @@ namespace ams::crypto::impl { DECLARE_ROUND_KEY_VAR(12); DECLARE_ROUND_KEY_VAR(13); DECLARE_ROUND_KEY_VAR(14); - uint8x16_t tweak0 = vld1q_u8(this->tweak); + uint8x16_t tweak0 = vld1q_u8(m_tweak); constexpr uint64_t xorv = 0x87ul; uint64_t high, low, mask; @@ -1171,10 +1171,10 @@ namespace ams::crypto::impl { dst += BlockSize; } - vst1q_u8(this->tweak, tweak0); + vst1q_u8(m_tweak, tweak0); - std::memcpy(this->last_block, src, BlockSize); - this->state = State_Processing; + std::memcpy(m_last_block, src, BlockSize); + m_state = State_Processing; return processed; } diff --git a/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.cpp b/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.cpp index f8cec27c7..e29f47087 100644 --- a/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.cpp +++ b/libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.cpp @@ -39,94 +39,94 @@ namespace ams::crypto::impl { /* Xor. */ for (size_t i = 0; i < BlockSize; i++) { - tmp[i] = this->tweak[i] ^ src[i]; + tmp[i] = m_tweak[i] ^ src[i]; } /* Crypt */ - this->cipher_func(tmp, tmp, this->cipher_ctx); + m_cipher_func(tmp, tmp, m_cipher_ctx); /* Xor. */ for (size_t i = 0; i < BlockSize; i++) { - dst[i] = this->tweak[i] ^ tmp[i]; + dst[i] = m_tweak[i] ^ tmp[i]; } - MultiplyTweakGeneric(reinterpret_cast(this->tweak)); + MultiplyTweakGeneric(reinterpret_cast(m_tweak)); } size_t XtsModeImpl::FinalizeEncryption(void *dst, size_t dst_size) { - AMS_ASSERT(this->state == State_Processing); + AMS_ASSERT(m_state == State_Processing); AMS_UNUSED(dst_size); u8 *dst_u8 = static_cast(dst); size_t processed = 0; - if (this->num_buffered == 0) { - this->ProcessBlock(dst_u8, this->last_block); + if (m_num_buffered == 0) { + this->ProcessBlock(dst_u8, m_last_block); processed = BlockSize; } else { - this->ProcessBlock(this->last_block, this->last_block); + this->ProcessBlock(m_last_block, m_last_block); - std::memcpy(this->buffer + this->num_buffered, this->last_block + this->num_buffered, BlockSize - this->num_buffered); + std::memcpy(m_buffer + m_num_buffered, m_last_block + m_num_buffered, BlockSize - m_num_buffered); - this->ProcessBlock(dst_u8, this->buffer); + this->ProcessBlock(dst_u8, m_buffer); - std::memcpy(dst_u8 + BlockSize, this->last_block, this->num_buffered); + std::memcpy(dst_u8 + BlockSize, m_last_block, m_num_buffered); - processed = BlockSize + this->num_buffered; + processed = BlockSize + m_num_buffered; } - this->state = State_Done; + m_state = State_Done; return processed; } size_t XtsModeImpl::FinalizeDecryption(void *dst, size_t dst_size) { - AMS_ASSERT(this->state == State_Processing); + AMS_ASSERT(m_state == State_Processing); AMS_UNUSED(dst_size); u8 *dst_u8 = static_cast(dst); size_t processed = 0; - if (this->num_buffered == 0) { - this->ProcessBlock(dst_u8, this->last_block); + if (m_num_buffered == 0) { + this->ProcessBlock(dst_u8, m_last_block); processed = BlockSize; } else { u8 tmp_tweak[BlockSize]; - std::memcpy(tmp_tweak, this->tweak, BlockSize); - MultiplyTweakGeneric(reinterpret_cast(this->tweak)); + std::memcpy(tmp_tweak, m_tweak, BlockSize); + MultiplyTweakGeneric(reinterpret_cast(m_tweak)); - this->ProcessBlock(this->last_block, this->last_block); + this->ProcessBlock(m_last_block, m_last_block); - std::memcpy(this->buffer + this->num_buffered, this->last_block + this->num_buffered, BlockSize - this->num_buffered); + std::memcpy(m_buffer + m_num_buffered, m_last_block + m_num_buffered, BlockSize - m_num_buffered); - std::memcpy(this->tweak, tmp_tweak, BlockSize); + std::memcpy(m_tweak, tmp_tweak, BlockSize); - this->ProcessBlock(dst_u8, this->buffer); + this->ProcessBlock(dst_u8, m_buffer); - std::memcpy(dst_u8 + BlockSize, this->last_block, this->num_buffered); + std::memcpy(dst_u8 + BlockSize, m_last_block, m_num_buffered); - processed = BlockSize + this->num_buffered; + processed = BlockSize + m_num_buffered; } - this->state = State_Done; + m_state = State_Done; return processed; } size_t XtsModeImpl::ProcessPartialData(u8 *dst, const u8 *src, size_t size) { size_t processed = 0; - std::memcpy(this->buffer + this->num_buffered, src, size); - this->num_buffered += size; + std::memcpy(m_buffer + m_num_buffered, src, size); + m_num_buffered += size; - if (this->num_buffered == BlockSize) { - if (this->state == State_Processing) { - this->ProcessBlock(dst, this->last_block); + if (m_num_buffered == BlockSize) { + if (m_state == State_Processing) { + this->ProcessBlock(dst, m_last_block); processed += BlockSize; } - std::memcpy(this->last_block, this->buffer, BlockSize); - this->num_buffered = 0; + std::memcpy(m_last_block, m_buffer, BlockSize); + m_num_buffered = 0; - this->state = State_Processing; + m_state = State_Processing; } return processed; @@ -135,8 +135,8 @@ namespace ams::crypto::impl { size_t XtsModeImpl::ProcessRemainingData(u8 *dst, const u8 *src, size_t size) { AMS_UNUSED(dst); - std::memcpy(this->buffer, src, size); - this->num_buffered = size; + std::memcpy(m_buffer, src, size); + m_num_buffered = size; return 0; }