hw/aes: Clean up key generator. (#7143)

src/core/hw/aes/key.cpp

@@ -3,21 +3,14 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <exception>
-#include <fstream>
 #include <optional>
 #include <sstream>
 #include <boost/iostreams/device/file_descriptor.hpp>
 #include <boost/iostreams/stream.hpp>
-#include <cryptopp/aes.h>
-#include <cryptopp/modes.h>
-#include <cryptopp/sha.h>
-#include <fmt/format.h>
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/file_sys/archive_ncch.h"
 #include "core/hle/service/fs/archive.h"
 #include "core/hw/aes/arithmetic128.h"
 #include "core/hw/aes/key.h"
@@ -31,18 +24,11 @@ namespace {
 // normal key dumped from a Wii U solving the equation:
 // NormalKey = (((KeyX ROL 2) XOR KeyY) + constant) ROL 87
 // On a real 3DS the generation for the normal key is hardware based, and thus the constant can't
-// get dumped. Generated normal keys are also not accesible on a 3DS. The used formula for
+// get dumped. Generated normal keys are also not accessible on a 3DS. The used formula for
 // calculating the constant is a software implementation of what the hardware generator does.
 constexpr AESKey generator_constant = {{0x1F, 0xF9, 0xE9, 0xAA, 0xC5, 0xFE, 0x04, 0x08, 0x02, 0x45,
                                         0x91, 0xDC, 0x5D, 0x52, 0x76, 0x8A}};
 
-struct KeyDesc {
-    char key_type;
-    std::size_t slot_id;
-    // This key is identical to the key with the same key_type and slot_id -1
-    bool same_as_before;
-};
-
 AESKey HexToKey(const std::string& hex) {
     if (hex.size() < 32) {
         throw std::invalid_argument("hex string is too short");
@@ -50,7 +36,7 @@ AESKey HexToKey(const std::string& hex) {
 
     AESKey key;
     for (std::size_t i = 0; i < key.size(); ++i) {
-        key[i] = static_cast<u8>(std::stoi(hex.substr(i * 2, 2), 0, 16));
+        key[i] = static_cast<u8>(std::stoi(hex.substr(i * 2, 2), nullptr, 16));
     }
 
     return key;
@@ -65,6 +51,40 @@ std::vector<u8> HexToVector(const std::string& hex) {
     return vector;
 }
 
+std::optional<std::size_t> ParseCommonKeyName(const std::string& full_name) {
+    std::size_t index;
+    int end;
+    if (std::sscanf(full_name.c_str(), "common%zd%n", &index, &end) == 1 &&
+        end == static_cast<int>(full_name.size())) {
+        return index;
+    } else {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::pair<std::size_t, std::string>> ParseNfcSecretName(
+    const std::string& full_name) {
+    std::size_t index;
+    int end;
+    if (std::sscanf(full_name.c_str(), "nfcSecret%zd%n", &index, &end) == 1) {
+        return std::make_pair(index, full_name.substr(end));
+    } else {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::pair<std::size_t, char>> ParseKeySlotName(const std::string& full_name) {
+    std::size_t slot;
+    char type;
+    int end;
+    if (std::sscanf(full_name.c_str(), "slot0x%zXKey%c%n", &slot, &type, &end) == 2 &&
+        end == static_cast<int>(full_name.size())) {
+        return std::make_pair(slot, type);
+    } else {
+        return std::nullopt;
+    }
+}
+
 struct KeySlot {
     std::optional<AESKey> x;
     std::optional<AESKey> y;
@@ -88,7 +108,7 @@ struct KeySlot {
         if (x && y) {
             normal = Lrot128(Add128(Xor128(Lrot128(*x, 2), *y), generator_constant), 87);
         } else {
-            normal = {};
+            normal.reset();
         }
     }
 
@@ -105,48 +125,13 @@ std::array<std::optional<AESKey>, NumDlpNfcKeyYs> dlp_nfc_key_y_slots;
 std::array<NfcSecret, NumNfcSecrets> nfc_secrets;
 AESIV nfc_iv;
 
-enum class FirmwareType : u32 {
+struct KeyDesc {
-    ARM9 = 0,  // uses NDMA
+    char key_type;
-    ARM11 = 1, // uses XDMA
+    std::size_t slot_id;
+    // This key is identical to the key with the same key_type and slot_id -1
+    bool same_as_before;
 };
 
-struct FirmwareSectionHeader {
-    u32_le offset;
-    u32_le phys_address;
-    u32_le size;
-    enum_le<FirmwareType> firmware_type;
-    std::array<u8, 0x20> hash; // SHA-256 hash
-};
-
-struct FIRM_Header {
-    u32_le magic;         // FIRM
-    u32_le boot_priority; // Usually 0
-    u32_le arm11_entrypoint;
-    u32_le arm9_entrypoint;
-    INSERT_PADDING_BYTES(0x30);                           // Reserved
-    std::array<FirmwareSectionHeader, 4> section_headers; // 1st ARM11?, 3rd ARM9
-    std::array<u8, 0x100> signature; // RSA-2048 signature of the FIRM header's hash
-};
-
-struct ARM9_Header {
-    AESKey enc_key_x;
-    AESKey key_y;
-    AESKey CTR;
-    std::array<u8, 8> size;  // in ASCII
-    INSERT_PADDING_BYTES(8); // Unknown
-    std::array<u8, 16> control_block;
-    std::array<u8, 16> hardware_debug_info;
-    std::array<u8, 16> enc_key_x_slot_16;
-};
-
-std::string KeyToString(AESKey& key) {
-    std::string s;
-    for (auto pos : key) {
-        s += fmt::format("{:02X}", pos);
-    }
-    return s;
-}
-
 void LoadBootromKeys() {
     constexpr std::array<KeyDesc, 80> keys = {
         {{'X', 0x2C, false}, {'X', 0x2D, true},  {'X', 0x2E, true},  {'X', 0x2F, true},
@@ -199,8 +184,7 @@ void LoadBootromKeys() {
             }
         }
 
-        LOG_DEBUG(HW_AES, "Loaded Slot{:#02x} Key{}: {}", key.slot_id, key.key_type,
+        LOG_DEBUG(HW_AES, "Loaded Slot{:#02x} Key{} from Bootrom9.", key.slot_id, key.key_type);
-                  KeyToString(new_key));
 
         switch (key.key_type) {
         case 'X':
@@ -219,227 +203,6 @@ void LoadBootromKeys() {
     }
 }
 
-void LoadNativeFirmKeysOld3DS() {
-    constexpr u64 native_firm_id = 0x00040138'00000002;
-    FileSys::NCCHArchive archive(native_firm_id, Service::FS::MediaType::NAND);
-    std::array<char, 8> exefs_filepath = {'.', 'f', 'i', 'r', 'm', 0, 0, 0};
-    FileSys::Path file_path = FileSys::MakeNCCHFilePath(
-        FileSys::NCCHFileOpenType::NCCHData, 0, FileSys::NCCHFilePathType::ExeFS, exefs_filepath);
-    FileSys::Mode open_mode = {};
-    open_mode.read_flag.Assign(1);
-    auto file_result = archive.OpenFile(file_path, open_mode);
-    if (file_result.Failed())
-        return;
-
-    auto firm = std::move(file_result).Unwrap();
-    const std::size_t size = firm->GetSize();
-    if (size != 966656) {
-        LOG_ERROR(HW_AES, "native firm has wrong size {}", size);
-        return;
-    }
-
-    const auto rsa = RSA::GetSlot(0);
-    if (!rsa) {
-        LOG_ERROR(HW_AES, "RSA slot is missing");
-        return;
-    }
-
-    std::vector<u8> firm_buffer(size);
-    firm->Read(0, firm_buffer.size(), firm_buffer.data());
-    firm->Close();
-
-    constexpr std::size_t SLOT_0x25_KEY_X_SECRET_OFFSET = 934444;
-    constexpr std::size_t SLOT_0x25_KEY_X_SECRET_SIZE = 64;
-    std::vector<u8> secret_data(SLOT_0x25_KEY_X_SECRET_SIZE);
-    std::memcpy(secret_data.data(), firm_buffer.data() + SLOT_0x25_KEY_X_SECRET_OFFSET,
-                secret_data.size());
-
-    auto asn1 = RSA::CreateASN1Message(secret_data);
-    auto result = rsa.GetSignature(asn1);
-    if (result.size() < 0x100) {
-        std::vector<u8> temp(0x100);
-        std::copy(result.begin(), result.end(), temp.end() - result.size());
-        result = temp;
-    } else if (result.size() > 0x100) {
-        result.resize(0x100);
-    }
-
-    CryptoPP::SHA256 sha;
-    std::array<u8, CryptoPP::SHA256::DIGESTSIZE> hash_result;
-    sha.CalculateDigest(hash_result.data(), result.data(), result.size());
-    AESKey key;
-    std::memcpy(key.data(), hash_result.data(), sizeof(key));
-    key_slots.at(0x2F).SetKeyY(key);
-    std::memcpy(key.data(), hash_result.data() + sizeof(key), sizeof(key));
-    key_slots.at(0x25).SetKeyX(key);
-}
-
-void LoadSafeModeNativeFirmKeysOld3DS() {
-    // Use the safe mode native firm instead of the normal mode since there are only 2 version of it
-    // and thus we can use fixed offsets
-
-    constexpr u64 safe_mode_native_firm_id = 0x00040138'00000003;
-
-    FileSys::NCCHArchive archive(safe_mode_native_firm_id, Service::FS::MediaType::NAND);
-    std::array<char, 8> exefs_filepath = {'.', 'f', 'i', 'r', 'm', 0, 0, 0};
-    FileSys::Path file_path = FileSys::MakeNCCHFilePath(
-        FileSys::NCCHFileOpenType::NCCHData, 0, FileSys::NCCHFilePathType::ExeFS, exefs_filepath);
-    FileSys::Mode open_mode = {};
-    open_mode.read_flag.Assign(1);
-    auto file_result = archive.OpenFile(file_path, open_mode);
-    if (file_result.Failed())
-        return;
-
-    auto firm = std::move(file_result).Unwrap();
-    const std::size_t size = firm->GetSize();
-    if (size != 843776) {
-        LOG_ERROR(HW_AES, "safe mode native firm has wrong size {}", size);
-        return;
-    }
-    std::vector<u8> firm_buffer(size);
-    firm->Read(0, firm_buffer.size(), firm_buffer.data());
-    firm->Close();
-    {
-        AESKey key;
-        constexpr std::size_t SLOT_0x31_KEY_Y_OFFSET = 817672;
-        std::memcpy(key.data(), firm_buffer.data() + SLOT_0x31_KEY_Y_OFFSET, sizeof(key));
-        key_slots.at(0x31).SetKeyY(key);
-        LOG_DEBUG(HW_AES, "Loaded Slot0x31 KeyY: {}", KeyToString(key));
-    }
-    auto LoadCommonKey = [&firm_buffer](std::size_t key_slot) -> AESKey {
-        constexpr std::size_t START_OFFSET = 836533;
-        constexpr std::size_t OFFSET = 0x14; // 0x10 bytes for key + 4 bytes between keys
-        AESKey key;
-        std::memcpy(key.data(), firm_buffer.data() + START_OFFSET + OFFSET * key_slot, sizeof(key));
-        return key;
-    };
-
-    for (std::size_t key_slot{0}; key_slot < 6; ++key_slot) {
-        AESKey key = LoadCommonKey(key_slot);
-        common_key_y_slots[key_slot] = key;
-        LOG_DEBUG(HW_AES, "Loaded common key{}: {}", key_slot, KeyToString(key));
-    }
-}
-
-void LoadNativeFirmKeysNew3DS() {
-    // The first 0x10 bytes of the secret_sector are used as a key to decrypt a KeyX from the
-    // native_firm
-    const std::string filepath =
-        FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + SECRET_SECTOR;
-    auto secret = FileUtil::IOFile(filepath, "rb");
-    if (!secret) {
-        return;
-    }
-    ASSERT(secret.GetSize() > 0x10);
-
-    AESKey secret_key;
-    secret.ReadArray(secret_key.data(), secret_key.size());
-
-    // Use the safe mode native firm instead of the normal mode since there are only 1 version of it
-    // and thus we can use fixed offsets
-    constexpr u64 safe_mode_native_firm_id = 0x00040138'20000003;
-
-    // TODO(B3N30): Add the 0x25 KeyX that gets initalized by native_firm
-
-    // TODO(B3N30): Add the 0x18 - 0x1F KeyX that gets initalized by native_firm. This probably
-    // requires the normal native firm with version > 9.6.0-X
-
-    FileSys::NCCHArchive archive(safe_mode_native_firm_id, Service::FS::MediaType::NAND);
-    std::array<char, 8> exefs_filepath = {'.', 'f', 'i', 'r', 'm', 0, 0, 0};
-    FileSys::Path file_path = FileSys::MakeNCCHFilePath(
-        FileSys::NCCHFileOpenType::NCCHData, 0, FileSys::NCCHFilePathType::ExeFS, exefs_filepath);
-    FileSys::Mode open_mode = {};
-    open_mode.read_flag.Assign(1);
-    auto file_result = archive.OpenFile(file_path, open_mode);
-    if (file_result.Failed())
-        return;
-
-    auto firm = std::move(file_result).Unwrap();
-    std::vector<u8> firm_buffer(firm->GetSize());
-    firm->Read(0, firm_buffer.size(), firm_buffer.data());
-    firm->Close();
-
-    FIRM_Header header;
-    std::memcpy(&header, firm_buffer.data(), sizeof(header));
-
-    auto MakeMagic = [](char a, char b, char c, char d) -> u32 {
-        return a | b << 8 | c << 16 | d << 24;
-    };
-    if (MakeMagic('F', 'I', 'R', 'M') != header.magic) {
-        LOG_ERROR(HW_AES, "N3DS SAFE MODE Native Firm has wrong header {}", header.magic);
-        return;
-    }
-
-    u32 arm9_offset(0);
-    u32 arm9_size(0);
-    for (auto section_header : header.section_headers) {
-        if (section_header.firmware_type == FirmwareType::ARM9) {
-            arm9_offset = section_header.offset;
-            arm9_size = section_header.size;
-            break;
-        }
-    }
-
-    if (arm9_offset != 0x66800) {
-        LOG_ERROR(HW_AES, "ARM9 binary at wrong offset: {}", arm9_offset);
-        return;
-    }
-    if (arm9_size != 0x8BA00) {
-        LOG_ERROR(HW_AES, "ARM9 binary has wrong size: {}", arm9_size);
-        return;
-    }
-
-    ARM9_Header arm9_header;
-    std::memcpy(&arm9_header, firm_buffer.data() + arm9_offset, sizeof(arm9_header));
-
-    AESKey keyX_slot0x15;
-    CryptoPP::ECB_Mode<CryptoPP::AES>::Decryption d;
-    d.SetKey(secret_key.data(), secret_key.size());
-    d.ProcessData(keyX_slot0x15.data(), arm9_header.enc_key_x.data(), arm9_header.enc_key_x.size());
-
-    key_slots.at(0x15).SetKeyX(keyX_slot0x15);
-    key_slots.at(0x15).SetKeyY(arm9_header.key_y);
-    auto normal_key_slot0x15 = key_slots.at(0x15).normal;
-    if (!normal_key_slot0x15) {
-        LOG_ERROR(HW_AES, "Failed to get normal key for slot id 0x15");
-        return;
-    }
-
-    constexpr u32 ARM9_BINARY_OFFSET = 0x800; // From the beginning of the ARM9 section
-    std::vector<u8> enc_arm9_binary;
-    enc_arm9_binary.resize(arm9_size - ARM9_BINARY_OFFSET);
-    ASSERT(enc_arm9_binary.size() + arm9_offset + ARM9_BINARY_OFFSET < firm_buffer.size());
-    std::memcpy(enc_arm9_binary.data(), firm_buffer.data() + arm9_offset + ARM9_BINARY_OFFSET,
-                enc_arm9_binary.size());
-
-    std::vector<u8> arm9_binary;
-    arm9_binary.resize(enc_arm9_binary.size());
-    CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption d2;
-    d2.SetKeyWithIV(normal_key_slot0x15->data(), normal_key_slot0x15->size(),
-                    arm9_header.CTR.data(), arm9_header.CTR.size());
-    d2.ProcessData(arm9_binary.data(), enc_arm9_binary.data(), enc_arm9_binary.size());
-    {
-        AESKey key;
-        constexpr std::size_t SLOT_0x31_KEY_Y_OFFSET = 517368;
-        std::memcpy(key.data(), arm9_binary.data() + SLOT_0x31_KEY_Y_OFFSET, sizeof(key));
-        key_slots.at(0x31).SetKeyY(key);
-        LOG_DEBUG(HW_AES, "Loaded Slot0x31 KeyY: {}", KeyToString(key));
-    }
-    auto LoadCommonKey = [&arm9_binary](std::size_t key_slot) -> AESKey {
-        constexpr std::size_t START_OFFSET = 541065;
-        constexpr std::size_t OFFSET = 0x14; // 0x10 bytes for key + 4 bytes between keys
-        AESKey key;
-        std::memcpy(key.data(), arm9_binary.data() + START_OFFSET + OFFSET * key_slot, sizeof(key));
-        return key;
-    };
-
-    for (std::size_t key_slot{0}; key_slot < 6; ++key_slot) {
-        AESKey key = LoadCommonKey(key_slot);
-        common_key_y_slots[key_slot] = key;
-        LOG_DEBUG(HW_AES, "Loaded common key{}: {}", key_slot, KeyToString(key));
-    }
-}
-
 void LoadPresetKeys() {
     const std::string filepath = FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + AES_KEYS;
     FileUtil::CreateFullPath(filepath); // Create path if not already created
@@ -467,19 +230,19 @@ void LoadPresetKeys() {
 
         const std::string& name = parts[0];
 
-        std::size_t nfc_secret_index;
+        const auto nfc_secret = ParseNfcSecretName(name);
-        if (std::sscanf(name.c_str(), "nfcSecret%zd", &nfc_secret_index) == 1) {
+        if (nfc_secret) {
             auto value = HexToVector(parts[1]);
-            if (nfc_secret_index >= nfc_secrets.size()) {
+            if (nfc_secret->first >= nfc_secrets.size()) {
-                LOG_ERROR(HW_AES, "Invalid NFC secret index {}", nfc_secret_index);
+                LOG_ERROR(HW_AES, "Invalid NFC secret index {}", nfc_secret->first);
-            } else if (name.ends_with("Phrase")) {
+            } else if (nfc_secret->second == "Phrase") {
-                nfc_secrets[nfc_secret_index].phrase = value;
+                nfc_secrets[nfc_secret->first].phrase = value;
-            } else if (name.ends_with("Seed")) {
+            } else if (nfc_secret->second == "Seed") {
-                nfc_secrets[nfc_secret_index].seed = value;
+                nfc_secrets[nfc_secret->first].seed = value;
-            } else if (name.ends_with("HmacKey")) {
+            } else if (nfc_secret->second == "HmacKey") {
-                nfc_secrets[nfc_secret_index].hmac_key = value;
+                nfc_secrets[nfc_secret->first].hmac_key = value;
             } else {
-                LOG_ERROR(HW_AES, "Invalid NFC secret {}", name);
+                LOG_ERROR(HW_AES, "Invalid NFC secret '{}'", name);
             }
             continue;
         }
@@ -492,12 +255,12 @@ void LoadPresetKeys() {
             continue;
         }
 
-        std::size_t common_key_index;
+        const auto common_key = ParseCommonKeyName(name);
-        if (std::sscanf(name.c_str(), "common%zd", &common_key_index) == 1) {
+        if (common_key) {
-            if (common_key_index >= common_key_y_slots.size()) {
+            if (common_key >= common_key_y_slots.size()) {
-                LOG_ERROR(HW_AES, "Invalid common key index {}", common_key_index);
+                LOG_ERROR(HW_AES, "Invalid common key index {}", common_key.value());
             } else {
-                common_key_y_slots[common_key_index] = key;
+                common_key_y_slots[common_key.value()] = key;
             }
             continue;
         }
@@ -517,30 +280,29 @@ void LoadPresetKeys() {
             continue;
         }
 
-        std::size_t slot_id;
+        const auto key_slot = ParseKeySlotName(name);
-        char key_type;
+        if (!key_slot) {
-        if (std::sscanf(name.c_str(), "slot0x%zXKey%c", &slot_id, &key_type) != 2) {
+            LOG_ERROR(HW_AES, "Invalid key name '{}'", name);
-            LOG_ERROR(HW_AES, "Invalid key name {}", name);
             continue;
         }
 
-        if (slot_id >= MaxKeySlotID) {
+        if (key_slot->first >= MaxKeySlotID) {
-            LOG_ERROR(HW_AES, "Out of range slot ID {:#X}", slot_id);
+            LOG_ERROR(HW_AES, "Out of range key slot ID {:#X}", key_slot->first);
             continue;
         }
 
-        switch (key_type) {
+        switch (key_slot->second) {
         case 'X':
-            key_slots.at(slot_id).SetKeyX(key);
+            key_slots.at(key_slot->first).SetKeyX(key);
             break;
         case 'Y':
-            key_slots.at(slot_id).SetKeyY(key);
+            key_slots.at(key_slot->first).SetKeyY(key);
             break;
         case 'N':
-            key_slots.at(slot_id).SetNormalKey(key);
+            key_slots.at(key_slot->first).SetNormalKey(key);
             break;
         default:
-            LOG_ERROR(HW_AES, "Invalid key type {}", key_type);
+            LOG_ERROR(HW_AES, "Invalid key type '{}'", key_slot->second);
             break;
         }
     }
@@ -550,14 +312,12 @@ void LoadPresetKeys() {
 
 void InitKeys(bool force) {
     static bool initialized = false;
-    if (initialized && !force)
+    if (initialized && !force) {
         return;
+    }
     initialized = true;
     HW::RSA::InitSlots();
     LoadBootromKeys();
-    LoadNativeFirmKeysOld3DS();
-    LoadSafeModeNativeFirmKeysOld3DS();
-    LoadNativeFirmKeysNew3DS();
     LoadPresetKeys();
 }
 

src/core/hw/aes/key.h

@@ -76,7 +76,6 @@ using AESIV = std::array<u8, AES_BLOCK_SIZE>;
 
 void InitKeys(bool force = false);
 
-void SetGeneratorConstant(const AESKey& key);
 void SetKeyX(std::size_t slot_id, const AESKey& key);
 void SetKeyY(std::size_t slot_id, const AESKey& key);
 void SetNormalKey(std::size_t slot_id, const AESKey& key);