Make XCI comply to review and style guidelines

1 files changed, 37 insertions, 40 deletions

diff --git a/src/core/crypto/key_manager.h b/src/core/crypto/key_manager.h
index b892a83f2..e04f1d49f 100644
--- a/src/core/crypto/key_manager.h
+++ b/src/core/crypto/key_manager.h
@@ -3,36 +3,37 @@
 // Refer to the license.txt file included.
 
 #pragma once
+
 #include <array>
 #include <unordered_map>
 #include <vector>
 #include <fmt/format.h>
 #include "common/common_types.h"
 
-namespace Crypto {
+namespace Core::Crypto {
 
-typedef std::array<u8, 0x10> Key128;
-typedef std::array<u8, 0x20> Key256;
-typedef std::array<u8, 0x20> SHA256Hash;
+using Key128 = std::array<u8, 0x10>;
+using Key256 = std::array<u8, 0x20>;
+using SHA256Hash = std::array<u8, 0x20>;
 
 static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
 static_assert(sizeof(Key256) == 32, "Key128 must be 128 bytes big.");
 
 enum class S256KeyType : u64 {
-    HEADER,  //
-    SD_SAVE, //
-    SD_NCA,  //
+    Header, //
+    SDSave, //
+    SDNCA,  //
 };
 
 enum class S128KeyType : u64 {
-    MASTER,          // f1=crypto revision
-    PACKAGE1,        // f1=crypto revision
-    PACKAGE2,        // f1=crypto revision
-    TITLEKEK,        // f1=crypto revision
-    ETICKET_RSA_KEK, //
-    KEY_AREA,        // f1=crypto revision f2=type {app, ocean, system}
-    SD_SEED,         //
-    TITLEKEY,        // f1=rights id LSB f2=rights id MSB
+    Master,        // f1=crypto revision
+    Package1,      // f1=crypto revision
+    Package2,      // f1=crypto revision
+    Titlekek,      // f1=crypto revision
+    ETicketRSAKek, //
+    KeyArea,       // f1=crypto revision f2=type {app, ocean, system}
+    SDSeed,        //
+    Titlekey,      // f1=rights id LSB f2=rights id MSB
 };
 
 enum class KeyAreaKeyType : u8 {
@@ -47,7 +48,7 @@ struct KeyIndex {
     u64 field1;
     u64 field2;
 
-    std::string DebugInfo() {
+    std::string DebugInfo() const {
         u8 key_size = 16;
         if (std::is_same_v<KeyType, S256KeyType>)
             key_size = 32;
@@ -60,15 +61,20 @@ struct KeyIndex {
 
 template <typename KeyType>
 bool operator==(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
-    return lhs.type == rhs.type && lhs.field1 == rhs.field1 && lhs.field2 == rhs.field2;
+    return std::tie(lhs.type, lhs.field1, lhs.field2) == std::tie(rhs.type, rhs.field1, rhs.field2);
 }
 
-} // namespace Crypto
+template <typename KeyType>
+bool operator!=(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
+    return !operator==(lhs, rhs);
+}
+
+} // namespace Core::Crypto
 
 namespace std {
 template <typename KeyType>
-struct hash<Crypto::KeyIndex<KeyType>> {
-    size_t operator()(const Crypto::KeyIndex<KeyType>& k) const {
+struct hash<Core::Crypto::KeyIndex<KeyType>> {
+    size_t operator()(const Core::Crypto::KeyIndex<KeyType>& k) const {
         using std::hash;
 
         return ((hash<u64>()(static_cast<u64>(k.type)) ^ (hash<u64>()(k.field1) << 1)) >> 1) ^
@@ -77,41 +83,32 @@ struct hash<Crypto::KeyIndex<KeyType>> {
 };
 } // namespace std
 
-namespace Crypto {
+namespace Core::Crypto {
 
 std::array<u8, 0x10> operator"" _array16(const char* str, size_t len);
 std::array<u8, 0x20> operator"" _array32(const char* str, size_t len);
 
-struct KeyManager {
-    void SetValidationMode(bool dev);
-    void LoadFromFile(std::string_view filename, bool is_title_keys);
+class KeyManager {
+public:
+    KeyManager();
 
-    bool HasKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0);
-    bool HasKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0);
+    bool HasKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+    bool HasKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
 
-    Key128 GetKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0);
-    Key256 GetKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0);
+    Key128 GetKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
+    Key256 GetKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
 
     void SetKey(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
     void SetKey(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
 
-    bool ValidateKey(S128KeyType key, u64 field1 = 0, u64 field2 = 0);
-    bool ValidateKey(S256KeyType key, u64 field1 = 0, u64 field2 = 0);
-
 private:
     std::unordered_map<KeyIndex<S128KeyType>, Key128> s128_keys;
     std::unordered_map<KeyIndex<S256KeyType>, Key256> s256_keys;
 
-    bool dev_mode = false;
+    bool dev_mode;
+    void LoadFromFile(std::string_view filename, bool is_title_keys);
 
-    static std::unordered_map<KeyIndex<S128KeyType>, SHA256Hash> s128_hash_prod;
-    static std::unordered_map<KeyIndex<S256KeyType>, SHA256Hash> s256_hash_prod;
-    static std::unordered_map<KeyIndex<S128KeyType>, SHA256Hash> s128_hash_dev;
-    static std::unordered_map<KeyIndex<S256KeyType>, SHA256Hash> s256_hash_dev;
     static std::unordered_map<std::string, KeyIndex<S128KeyType>> s128_file_id;
     static std::unordered_map<std::string, KeyIndex<S256KeyType>> s256_file_id;
 };
-
-extern KeyManager keys;
-
-} // namespace Crypto
+} // namespace Core::Crypto