diff --git a/src/core/crypto/key_manager.cpp b/src/core/crypto/key_manager.cpp index 50945eee91..6d0b32ba70 100644 --- a/src/core/crypto/key_manager.cpp +++ b/src/core/crypto/key_manager.cpp @@ -45,6 +45,13 @@ constexpr u64 CURRENT_CRYPTO_REVISION = 0x5; using Common::AsArray; +// clang-format off +constexpr std::array eticket_source_hashes{ + AsArray("B71DB271DC338DF380AA2C4335EF8873B1AFD408E80B3582D8719FC81C5E511C"), // eticket_rsa_kek_source + AsArray("E8965A187D30E57869F562D04383C996DE487BBA5761363D2D4D32391866A85C"), // eticket_rsa_kekek_source +}; +// clang-format on + constexpr std::array>, 30> s128_file_id{{ {"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}}, {"eticket_rsa_kek_source", @@ -1110,25 +1117,81 @@ void KeyManager::DeriveBase() { void KeyManager::DeriveETicket(PartitionDataManager& data, const FileSys::ContentProvider& provider) { - // The emulator no longer derives the ETicket RSA Kek. - // It is now required for the user to provide this key in their keys file. - if (!HasKey(S128KeyType::ETicketRSAKek)) { - LOG_WARNING(Crypto, "ETicket RSA Kek not found, skipping eTicket parsing."); + // ETicket keys + const auto es = provider.GetEntry(0x0100000000000033, FileSys::ContentRecordType::Program); + + if (es == nullptr) { return; } - // Decrypt PRODINFO to get the extended kek needed for the RSA keypair. + const auto exefs = es->GetExeFS(); + if (exefs == nullptr) { + return; + } + + const auto main = exefs->GetFile("main"); + if (main == nullptr) { + return; + } + + const auto bytes = main->ReadAllBytes(); + + const auto eticket_kek = FindKeyFromHex16(bytes, eticket_source_hashes[0]); + const auto eticket_kekek = FindKeyFromHex16(bytes, eticket_source_hashes[1]); + + const auto seed3 = data.GetRSAKekSeed3(); + const auto mask0 = data.GetRSAKekMask0(); + + if (eticket_kek != Key128{}) { + SetKey(S128KeyType::Source, eticket_kek, static_cast(SourceKeyType::ETicketKek)); + } + if (eticket_kekek != Key128{}) { + SetKey(S128KeyType::Source, eticket_kekek, + static_cast(SourceKeyType::ETicketKekek)); + } + if (seed3 != Key128{}) { + SetKey(S128KeyType::RSAKek, seed3, static_cast(RSAKekType::Seed3)); + } + if (mask0 != Key128{}) { + SetKey(S128KeyType::RSAKek, mask0, static_cast(RSAKekType::Mask0)); + } + if (eticket_kek == Key128{} || eticket_kekek == Key128{} || seed3 == Key128{} || + mask0 == Key128{}) { + return; + } + + const Key128 rsa_oaep_kek = seed3 ^ mask0; + if (rsa_oaep_kek == Key128{}) { + return; + } + + SetKey(S128KeyType::Source, rsa_oaep_kek, + static_cast(SourceKeyType::RSAOaepKekGeneration)); + + Key128 temp_kek{}; + Key128 temp_kekek{}; + Key128 eticket_final{}; + + // Derive ETicket RSA Kek + AESCipher es_master(GetKey(S128KeyType::Master), Mode::ECB); + es_master.Transcode(rsa_oaep_kek.data(), rsa_oaep_kek.size(), temp_kek.data(), Op::Decrypt); + AESCipher es_kekek(temp_kek, Mode::ECB); + es_kekek.Transcode(eticket_kekek.data(), eticket_kekek.size(), temp_kekek.data(), Op::Decrypt); + AESCipher es_kek(temp_kekek, Mode::ECB); + es_kek.Transcode(eticket_kek.data(), eticket_kek.size(), eticket_final.data(), Op::Decrypt); + + if (eticket_final == Key128{}) { + return; + } + + SetKey(S128KeyType::ETicketRSAKek, eticket_final); + + // Titlekeys data.DecryptProdInfo(GetBISKey(0)); - // The extended kek is read from the decrypted PRODINFO. eticket_extended_kek = data.GetETicketExtendedKek(); WriteKeyToFile(KeyCategory::Console, "eticket_extended_kek", eticket_extended_kek); - - // Derive the final RSA keypair using the user-provided ETicketRSAKek - // and the extended kek from PRODINFO. DeriveETicketRSAKey(); - - // Load personalized tickets from the NAND. PopulateTickets(); } @@ -1209,6 +1272,22 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) { encrypted_keyblobs[i]); } + SetKeyWrapped(S128KeyType::Source, data.GetPackage2KeySource(), + static_cast(SourceKeyType::Package2)); + SetKeyWrapped(S128KeyType::Source, data.GetAESKekGenerationSource(), + static_cast(SourceKeyType::AESKekGeneration)); + SetKeyWrapped(S128KeyType::Source, data.GetTitlekekSource(), + static_cast(SourceKeyType::Titlekek)); + SetKeyWrapped(S128KeyType::Source, data.GetMasterKeySource(), + static_cast(SourceKeyType::Master)); + SetKeyWrapped(S128KeyType::Source, data.GetKeyblobMACKeySource(), + static_cast(SourceKeyType::KeyblobMAC)); + + for (size_t i = 0; i < PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH; ++i) { + SetKeyWrapped(S128KeyType::Source, data.GetKeyblobKeySource(i), + static_cast(SourceKeyType::Keyblob), i); + } + if (data.HasFuses()) { SetKeyWrapped(S128KeyType::SecureBoot, data.GetSecureBootKey()); } @@ -1223,6 +1302,13 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) { } } + const auto masters = data.GetTZMasterKeys(latest_master); + for (size_t i = 0; i < masters.size(); ++i) { + if (masters[i] != Key128{} && !HasKey(S128KeyType::Master, i)) { + SetKey(S128KeyType::Master, masters[i], i); + } + } + DeriveBase(); if (!data.HasPackage2()) @@ -1236,6 +1322,27 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) { } data.DecryptPackage2(package2_keys, Package2Type::NormalMain); + SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyApplicationSource(), + static_cast(SourceKeyType::KeyAreaKey), + static_cast(KeyAreaKeyType::Application)); + SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeyOceanSource(), + static_cast(SourceKeyType::KeyAreaKey), + static_cast(KeyAreaKeyType::Ocean)); + SetKeyWrapped(S128KeyType::Source, data.GetKeyAreaKeySystemSource(), + static_cast(SourceKeyType::KeyAreaKey), + static_cast(KeyAreaKeyType::System)); + SetKeyWrapped(S128KeyType::Source, data.GetSDKekSource(), + static_cast(SourceKeyType::SDKek)); + SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDSaveKeySource(), + static_cast(SDKeyType::Save)); + SetKeyWrapped(S256KeyType::SDKeySource, data.GetSDNCAKeySource(), + static_cast(SDKeyType::NCA)); + SetKeyWrapped(S128KeyType::Source, data.GetHeaderKekSource(), + static_cast(SourceKeyType::HeaderKek)); + SetKeyWrapped(S256KeyType::HeaderSource, data.GetHeaderKeySource()); + SetKeyWrapped(S128KeyType::Source, data.GetAESKeyGenerationSource(), + static_cast(SourceKeyType::AESKeyGeneration)); + DeriveBase(); } diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp index e185838e57..8e4fc2e595 100644 --- a/src/core/crypto/partition_data_manager.cpp +++ b/src/core/crypto/partition_data_manager.cpp @@ -4,6 +4,11 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +// NOTE TO FUTURE MAINTAINERS: +// When a new version of switch cryptography is released, +// hash the new keyblob source and master key and add the hashes to +// the arrays below. + #include #include #include @@ -44,7 +49,178 @@ struct Package2Header { }; static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size."); -const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = 32; +// clang-format off +constexpr std::array source_hashes{ + AsArray("B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"), // keyblob_mac_key_source + AsArray("7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"), // master_key_source + AsArray("21E2DF100FC9E094DB51B47B9B1D6E94ED379DB8B547955BEF8FE08D8DD35603"), // package2_key_source + AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // aes_kek_generation_source + AsArray("FBD10056999EDC7ACDB96098E47E2C3606230270D23281E671F0F389FC5BC585"), // aes_key_generation_source + AsArray("C48B619827986C7F4E3081D59DB2B460C84312650E9A8E6B458E53E8CBCA4E87"), // titlekek_source + AsArray("04AD66143C726B2A139FB6B21128B46F56C553B2B3887110304298D8D0092D9E"), // key_area_key_application_source + AsArray("FD434000C8FF2B26F8E9A9D2D2C12F6BE5773CBB9DC86300E1BD99F8EA33A417"), // key_area_key_ocean_source + AsArray("1F17B1FD51AD1C2379B58F152CA4912EC2106441E51722F38700D5937A1162F7"), // key_area_key_system_source + AsArray("6B2ED877C2C52334AC51E59ABFA7EC457F4A7D01E46291E9F2EAA45F011D24B7"), // sd_card_kek_source + AsArray("D482743563D3EA5DCDC3B74E97C9AC8A342164FA041A1DC80F17F6D31E4BC01C"), // sd_card_save_key_source + AsArray("2E751CECF7D93A2B957BD5FFCB082FD038CC2853219DD3092C6DAB9838F5A7CC"), // sd_card_nca_key_source + AsArray("1888CAED5551B3EDE01499E87CE0D86827F80820EFB275921055AA4E2ABDFFC2"), // header_kek_source + AsArray("8F783E46852DF6BE0BA4E19273C4ADBAEE16380043E1B8C418C4089A8BD64AA6"), // header_key_source + AsArray("D1757E52F1AE55FA882EC690BC6F954AC46A83DC22F277F8806BD55577C6EED7"), // rsa_kek_seed3 + AsArray("FC02B9D37B42D7A1452E71444F1F700311D1132E301A83B16062E72A78175085"), // rsa_kek_mask0 +}; +// clang-format on + +// clang-format off +constexpr std::array keyblob_source_hashes{ + AsArray("8A06FE274AC491436791FDB388BCDD3AB9943BD4DEF8094418CDAC150FD73786"), // keyblob_key_source_00 + AsArray("2D5CAEB2521FEF70B47E17D6D0F11F8CE2C1E442A979AD8035832C4E9FBCCC4B"), // keyblob_key_source_01 + AsArray("61C5005E713BAE780641683AF43E5F5C0E03671117F702F401282847D2FC6064"), // keyblob_key_source_02 + AsArray("8E9795928E1C4428E1B78F0BE724D7294D6934689C11B190943923B9D5B85903"), // keyblob_key_source_03 + AsArray("95FA33AF95AFF9D9B61D164655B32710ED8D615D46C7D6CC3CC70481B686B402"), // keyblob_key_source_04 + AsArray("3F5BE7B3C8B1ABD8C10B4B703D44766BA08730562C172A4FE0D6B866B3E2DB3E"), // keyblob_key_source_05 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_06 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_07 + + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_08 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_09 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0A + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0B + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0C + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0D + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0E + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_0F + + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_10 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_11 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_12 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_13 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_14 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_15 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_16 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_17 + + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_18 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_19 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1A + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1B + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1C + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1D + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1E + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // keyblob_key_source_1F +}; +// clang-format on + +// clang-format off +constexpr std::array master_key_hashes{ + AsArray("0EE359BE3C864BB0782E1D70A718A0342C551EED28C369754F9C4F691BECF7CA"), // master_key_00 + AsArray("4FE707B7E4ABDAF727C894AAF13B1351BFE2AC90D875F73B2E20FA94B9CC661E"), // master_key_01 + AsArray("79277C0237A2252EC3DFAC1F7C359C2B3D121E9DB15BB9AB4C2B4408D2F3AE09"), // master_key_02 + AsArray("4F36C565D13325F65EE134073C6A578FFCB0008E02D69400836844EAB7432754"), // master_key_03 + AsArray("75FF1D95D26113550EE6FCC20ACB58E97EDEB3A2FF52543ED5AEC63BDCC3DA50"), // master_key_04 + AsArray("EBE2BCD6704673EC0F88A187BB2AD9F1CC82B718C389425941BDC194DC46B0DD"), // master_key_05 + AsArray("9497E6779F5D840F2BBA1DE4E95BA1D6F21EFC94717D5AE5CA37D7EC5BD37A19"), // master_key_06 + AsArray("4EC96B8CB01B8DCE382149443430B2B6EBCB2983348AFA04A25E53609DABEDF6"), // master_key_07 + + AsArray("2998E2E23609BC2675FF062A2D64AF5B1B78DFF463B24119D64A1B64F01B2D51"), // master_key_08 + AsArray("9D486A98067C44B37CF173D3BF577891EB6081FF6B4A166347D9DBBF7025076B"), // master_key_09 + AsArray("4EC5A237A75A083A9C5F6CF615601522A7F822D06BD4BA32612C9CEBBB29BD45"), // master_key_0A + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0B + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0C + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0D + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0E + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_0F + + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_10 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_11 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_12 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_13 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_14 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_15 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_16 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_17 + + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_18 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_19 + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1A + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1B + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1C + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1D + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1E + AsArray("0000000000000000000000000000000000000000000000000000000000000000"), // master_key_1F +}; +// clang-format on + +static constexpr u8 CalculateMaxKeyblobSourceHash() { + const auto is_zero = [](const auto& data) { + // TODO: Replace with std::all_of whenever mingw decides to update their + // libraries to include the constexpr variant of it. + for (const auto element : data) { + if (element != 0) { + return false; + } + } + return true; + }; + + for (s8 i = 0x1F; i >= 0; --i) { + if (!is_zero(keyblob_source_hashes[i])) { + return static_cast(i + 1); + } + } + + return 0; +} + +const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = CalculateMaxKeyblobSourceHash(); + +template +std::array FindKeyFromHex(const std::vector& binary, + const std::array& hash) { + if (binary.size() < key_size) + return {}; + + std::array temp{}; + for (size_t i = 0; i < binary.size() - key_size; ++i) { + mbedtls_sha256(binary.data() + i, key_size, temp.data(), 0); + + if (temp != hash) + continue; + + std::array out{}; + std::memcpy(out.data(), binary.data() + i, key_size); + return out; + } + + return {}; +} + +std::array FindKeyFromHex16(const std::vector& binary, std::array hash) { + return FindKeyFromHex<0x10>(binary, hash); +} + +static std::array FindEncryptedMasterKeyFromHex(const std::vector& binary, + const Key128& key) { + if (binary.size() < 0x10) + return {}; + + SHA256Hash temp{}; + Key128 dec_temp{}; + std::array out{}; + AESCipher cipher(key, Mode::ECB); + for (size_t i = 0; i < binary.size() - 0x10; ++i) { + cipher.Transcode(binary.data() + i, dec_temp.size(), dec_temp.data(), Op::Decrypt); + mbedtls_sha256(dec_temp.data(), dec_temp.size(), temp.data(), 0); + + for (size_t k = 0; k < out.size(); ++k) { + if (temp == master_key_hashes[k]) { + out[k] = dec_temp; + break; + } + } + } + + return out; +} static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir, const std::string& name) { @@ -111,10 +287,52 @@ std::vector PartitionDataManager::GetSecureMonitor() const { return secure_monitor_bytes; } +std::array PartitionDataManager::GetPackage2KeySource() const { + return FindKeyFromHex(secure_monitor_bytes, source_hashes[2]); +} + +std::array PartitionDataManager::GetAESKekGenerationSource() const { + return FindKeyFromHex(secure_monitor_bytes, source_hashes[3]); +} + +std::array PartitionDataManager::GetTitlekekSource() const { + return FindKeyFromHex(secure_monitor_bytes, source_hashes[5]); +} + +std::array, 32> PartitionDataManager::GetTZMasterKeys( + std::array master_key) const { + return FindEncryptedMasterKeyFromHex(secure_monitor_bytes, master_key); +} + +std::array PartitionDataManager::GetRSAKekSeed3() const { + return FindKeyFromHex(secure_monitor_bytes, source_hashes[14]); +} + +std::array PartitionDataManager::GetRSAKekMask0() const { + return FindKeyFromHex(secure_monitor_bytes, source_hashes[15]); +} + std::vector PartitionDataManager::GetPackage1Decrypted() const { return package1_decrypted_bytes; } +std::array PartitionDataManager::GetMasterKeySource() const { + return FindKeyFromHex(package1_decrypted_bytes, source_hashes[1]); +} + +std::array PartitionDataManager::GetKeyblobMACKeySource() const { + return FindKeyFromHex(package1_decrypted_bytes, source_hashes[0]); +} + +std::array PartitionDataManager::GetKeyblobKeySource(std::size_t revision) const { + if (keyblob_source_hashes[revision] == SHA256Hash{}) { + LOG_WARNING(Crypto, + "No keyblob source hash for crypto revision {:02X}! Cannot derive keys...", + revision); + } + return FindKeyFromHex(package1_decrypted_bytes, keyblob_source_hashes[revision]); +} + bool PartitionDataManager::HasFuses() const { return fuses != nullptr; } @@ -226,10 +444,46 @@ const std::vector& PartitionDataManager::GetPackage2FSDecompressed(Package2T return package2_fs.at(static_cast(type)); } +std::array PartitionDataManager::GetKeyAreaKeyApplicationSource(Package2Type type) const { + return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[6]); +} + +std::array PartitionDataManager::GetKeyAreaKeyOceanSource(Package2Type type) const { + return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[7]); +} + +std::array PartitionDataManager::GetKeyAreaKeySystemSource(Package2Type type) const { + return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[8]); +} + +std::array PartitionDataManager::GetSDKekSource(Package2Type type) const { + return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[9]); +} + +std::array PartitionDataManager::GetSDSaveKeySource(Package2Type type) const { + return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[10]); +} + +std::array PartitionDataManager::GetSDNCAKeySource(Package2Type type) const { + return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[11]); +} + +std::array PartitionDataManager::GetHeaderKekSource(Package2Type type) const { + return FindKeyFromHex(package2_fs.at(static_cast(type)), source_hashes[12]); +} + +std::array PartitionDataManager::GetHeaderKeySource(Package2Type type) const { + return FindKeyFromHex<0x20>(package2_fs.at(static_cast(type)), source_hashes[13]); +} + const std::vector& PartitionDataManager::GetPackage2SPLDecompressed(Package2Type type) const { return package2_spl.at(static_cast(type)); } +std::array PartitionDataManager::GetAESKeyGenerationSource(Package2Type type) const { + return FindKeyFromHex(package2_spl.at(static_cast(type)), source_hashes[4]); +} + bool PartitionDataManager::HasProdInfo() const { return prodinfo != nullptr; } @@ -255,4 +509,4 @@ std::array PartitionDataManager::GetETicketExtendedKek() const { prodinfo_decrypted->Read(out.data(), out.size(), 0x3890); return out; } -} // namespace Core::Crypto \ No newline at end of file +} // namespace Core::Crypto diff --git a/src/core/crypto/partition_data_manager.h b/src/core/crypto/partition_data_manager.h index 2a01aed228..4354a21e6a 100644 --- a/src/core/crypto/partition_data_manager.h +++ b/src/core/crypto/partition_data_manager.h @@ -1,6 +1,3 @@ -// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project -// SPDX-License-Identifier: GPL-3.0-or-later - // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later @@ -39,7 +36,16 @@ public: EncryptedKeyBlob GetEncryptedKeyblob(std::size_t index) const; EncryptedKeyBlobs GetEncryptedKeyblobs() const; std::vector GetSecureMonitor() const; + std::array GetPackage2KeySource() const; + std::array GetAESKekGenerationSource() const; + std::array GetTitlekekSource() const; + std::array, 0x20> GetTZMasterKeys(std::array master_key) const; + std::array GetRSAKekSeed3() const; + std::array GetRSAKekMask0() const; std::vector GetPackage1Decrypted() const; + std::array GetMasterKeySource() const; + std::array GetKeyblobMACKeySource() const; + std::array GetKeyblobKeySource(std::size_t revision) const; // Fuses bool HasFuses() const; @@ -57,8 +63,21 @@ public: Package2Type type); const std::vector& GetPackage2FSDecompressed( Package2Type type = Package2Type::NormalMain) const; + std::array GetKeyAreaKeyApplicationSource( + Package2Type type = Package2Type::NormalMain) const; + std::array GetKeyAreaKeyOceanSource( + Package2Type type = Package2Type::NormalMain) const; + std::array GetKeyAreaKeySystemSource( + Package2Type type = Package2Type::NormalMain) const; + std::array GetSDKekSource(Package2Type type = Package2Type::NormalMain) const; + std::array GetSDSaveKeySource(Package2Type type = Package2Type::NormalMain) const; + std::array GetSDNCAKeySource(Package2Type type = Package2Type::NormalMain) const; + std::array GetHeaderKekSource(Package2Type type = Package2Type::NormalMain) const; + std::array GetHeaderKeySource(Package2Type type = Package2Type::NormalMain) const; const std::vector& GetPackage2SPLDecompressed( Package2Type type = Package2Type::NormalMain) const; + std::array GetAESKeyGenerationSource( + Package2Type type = Package2Type::NormalMain) const; // PRODINFO bool HasProdInfo() const; @@ -85,4 +104,6 @@ private: std::array, 6> package2_spl; }; -} // namespace Core::Crypto \ No newline at end of file +std::array FindKeyFromHex16(const std::vector& binary, std::array hash); + +} // namespace Core::Crypto diff --git a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc index 28699fa33b..34f77b0446 100644 --- a/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc +++ b/src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc @@ -273,31 +273,34 @@ void AxxEmitX64::EmitExclusiveWriteMemory(AxxEmitContext& ctx, IR::Inst* inst) { auto args = ctx.reg_alloc.GetArgumentInfo(inst); const bool ordered = IsOrdered(args[3].GetImmediateAccType()); - if constexpr (bitsize == 128) { + if constexpr (bitsize != 128) { + ctx.reg_alloc.HostCall(inst, {}, args[1], args[2]); + } else { ctx.reg_alloc.Use(args[1], ABI_PARAM2); ctx.reg_alloc.Use(args[2], HostLoc::XMM1); ctx.reg_alloc.EndOfAllocScope(); ctx.reg_alloc.HostCall(inst); - } else { - ctx.reg_alloc.HostCall(inst, {}, args[1], args[2]); } - const Xbyak::Reg64 tmp = ctx.reg_alloc.ScratchGpr(); Xbyak::Label end; + code.mov(code.ABI_RETURN, u32(1)); - code.movzx(tmp.cvt32(), code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)]); - code.test(tmp.cvt8(), tmp.cvt8()); + code.cmp(code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)], u8(0)); code.je(end); - code.xor_(tmp.cvt32(), tmp.cvt32()); - code.xchg(tmp.cvt8(), code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)]); - code.mov(code.ABI_PARAM1, u64(&conf)); + code.mov(code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)], u8(0)); + code.mov(code.ABI_PARAM1, reinterpret_cast(&conf)); if constexpr (bitsize != 128) { using T = mcl::unsigned_integer_of_size; - code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, T value) -> u32 { - return conf.global_monitor->DoExclusiveOperation(conf.processor_id, vaddr, [&](T expected) -> bool { - return (conf.callbacks->*callback)(vaddr, value, expected); - }) ? 0 : 1; - }); + + code.CallLambda( + [](AxxUserConfig& conf, Axx::VAddr vaddr, T value) -> u32 { + return conf.global_monitor->DoExclusiveOperation(conf.processor_id, vaddr, + [&](T expected) -> bool { + return (conf.callbacks->*callback)(vaddr, value, expected); + }) + ? 0 + : 1; + }); if (ordered) { code.mfence(); } @@ -305,11 +308,15 @@ void AxxEmitX64::EmitExclusiveWriteMemory(AxxEmitContext& ctx, IR::Inst* inst) { ctx.reg_alloc.AllocStackSpace(16 + ABI_SHADOW_SPACE); code.lea(code.ABI_PARAM3, ptr[rsp + ABI_SHADOW_SPACE]); code.movaps(xword[code.ABI_PARAM3], xmm1); - code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& value) -> u32 { - return conf.global_monitor->DoExclusiveOperation(conf.processor_id, vaddr, [&](Vector expected) -> bool { - return (conf.callbacks->*callback)(vaddr, value, expected); - }) ? 0 : 1; - }); + code.CallLambda( + [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& value) -> u32 { + return conf.global_monitor->DoExclusiveOperation(conf.processor_id, vaddr, + [&](Vector expected) -> bool { + return (conf.callbacks->*callback)(vaddr, value, expected); + }) + ? 0 + : 1; + }); if (ordered) { code.mfence(); } @@ -430,11 +437,10 @@ void AxxEmitX64::EmitExclusiveWriteMemoryInline(AxxEmitContext& ctx, IR::Inst* i SharedLabel end = GenSharedLabel(); - code.mov(status, u32(1)); - code.movzx(tmp.cvt32(), code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)]); - code.test(tmp.cvt8(), tmp.cvt8()); - code.je(*end, code.T_NEAR); code.mov(tmp, mcl::bit_cast(GetExclusiveMonitorAddressPointer(conf.global_monitor, conf.processor_id))); + code.mov(status, u32(1)); + code.cmp(code.byte[code.ABI_JIT_PTR + offsetof(AxxJitState, exclusive_state)], u8(0)); + code.je(*end, code.T_NEAR); code.cmp(qword[tmp], vaddr); code.jne(*end, code.T_NEAR); @@ -468,29 +474,30 @@ void AxxEmitX64::EmitExclusiveWriteMemoryInline(AxxEmitContext& ctx, IR::Inst* i const auto location = code.getCurr(); - switch (bitsize) { - case 8: - code.lock(); - code.cmpxchg(code.byte[dest_ptr], value.cvt8()); - break; - case 16: - code.lock(); - code.cmpxchg(word[dest_ptr], value.cvt16()); - break; - case 32: - code.lock(); - code.cmpxchg(dword[dest_ptr], value.cvt32()); - break; - case 64: - code.lock(); - code.cmpxchg(qword[dest_ptr], value.cvt64()); - break; - case 128: + if constexpr (bitsize == 128) { code.lock(); code.cmpxchg16b(ptr[dest_ptr]); - break; - default: - UNREACHABLE(); + } else { + switch (bitsize) { + case 8: + code.lock(); + code.cmpxchg(code.byte[dest_ptr], value.cvt8()); + break; + case 16: + code.lock(); + code.cmpxchg(word[dest_ptr], value.cvt16()); + break; + case 32: + code.lock(); + code.cmpxchg(dword[dest_ptr], value.cvt32()); + break; + case 64: + code.lock(); + code.cmpxchg(qword[dest_ptr], value.cvt64()); + break; + default: + UNREACHABLE(); + } } code.setnz(status.cvt8()); diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp index 7befe235c4..fb5157a658 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp @@ -1377,13 +1377,17 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src, // As per the size-compatible formats section of vulkan, copy manually via ReinterpretImage // these images that aren't size-compatible if (BytesPerBlock(src.info.format) != BytesPerBlock(dst.info.format)) { - auto oneCopy = VideoCommon::ImageCopy{ - .src_offset = VideoCommon::Offset3D(0, 0, 0), - .dst_offset = VideoCommon::Offset3D(0, 0, 0), - .extent = dst.info.size - }; + + if (src.info.type == ImageType::Linear || dst.info.type == ImageType::Linear) { + return; + } + + auto oneCopy = VideoCommon::ImageCopy{.src_offset = VideoCommon::Offset3D(0, 0, 0), + .dst_offset = VideoCommon::Offset3D(0, 0, 0), + .extent = dst.info.size}; return ReinterpretImage(dst, src, std::span{&oneCopy, 1}); } + boost::container::small_vector vk_copies(copies.size()); const VkImageAspectFlags aspect_mask = dst.AspectMask(); ASSERT(aspect_mask == src.AspectMask()); @@ -1561,10 +1565,10 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, since tropic didn't want to touch it for a long time, so it needs a rewrite from someone better than me at vulkan. */ // CHANGE: Gate the MSAA path more strictly and only use it for color, when the pass and device - // support are available. Avoid running the MSAA path when prerequisites aren't met, - // preventing validation and runtime issues. + // support are available. Avoid running the MSAA path when prerequisites aren't met, preventing + // validation and runtime issues. const bool wants_msaa_upload = info.num_samples > 1 && - (aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0 && + aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT && runtime->CanUploadMSAA() && runtime->msaa_copy_pass != nullptr && runtime->device.IsStorageImageMultisampleSupported(); @@ -1574,8 +1578,7 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, temp_info.num_samples = 1; // CHANGE: Build a fresh VkImageCreateInfo with robust usage flags for the temp image. - // Using the target image's usage as-is could miss STORAGE/TRANSFER bits and trigger - // validation errors. + // Using the target image's usage as-is could miss STORAGE/TRANSFER bits and trigger validation errors. VkImageCreateInfo image_ci = MakeImageCreateInfo(runtime->device, temp_info); image_ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT; @@ -1585,7 +1588,7 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, auto temp_wrapper = std::make_shared(*runtime, temp_info, 0, 0); temp_wrapper->original_image = runtime->memory_allocator.CreateImage(image_ci); temp_wrapper->current_image = &Image::original_image; - temp_wrapper->aspect_mask = aspect_mask; + temp_wrapper->aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT; temp_wrapper->initialized = true; // Upload to the temporary non-MSAA image @@ -1594,17 +1597,18 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, const VkBuffer src_buffer = buffer; const VkImage temp_vk_image = *temp_wrapper->original_image; const VkImageAspectFlags vk_aspect_mask = temp_wrapper->aspect_mask; - scheduler->Record([src_buffer, temp_vk_image, vk_aspect_mask, vk_copies, + // CHANGE: capture shared_ptr to pin lifetime through submission keep = temp_wrapper](vk::CommandBuffer cmdbuf) { CopyBufferToImage(cmdbuf, src_buffer, temp_vk_image, vk_aspect_mask, false, vk_copies); }); // Use MSAACopyPass to convert from non-MSAA to MSAA + // CHANGE: only lifetime and usage were fixed. std::vector image_copies; image_copies.reserve(copies.size()); for (const auto& copy : copies) { - VideoCommon::ImageCopy image_copy{}; + VideoCommon::ImageCopy image_copy; image_copy.src_offset = {0, 0, 0}; // Use zero offset for source image_copy.dst_offset = copy.image_offset; image_copy.src_subresource = copy.image_subresource; @@ -1617,9 +1621,11 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, /*msaa_to_non_msaa=*/false); std::exchange(initialized, true); - const u64 tick = scheduler->Flush(); - scheduler->Wait(tick); + // CHANGE: Add a no-op recording that captures temp_wrapper to ensure it stays alive + // at least until commands are submitted/recorded. + scheduler->Record([keep = std::move(temp_wrapper)](vk::CommandBuffer) {}); + // CHANGE: Restore scaling before returning from the MSAA path. if (is_rescaled) { ScaleUp(); } @@ -1632,11 +1638,10 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, const VkBuffer src_buffer = buffer; const VkImage vk_image = *original_image; const VkImageAspectFlags vk_aspect_mask = aspect_mask; - const bool was_initialized = std::exchange(initialized, true); - - scheduler->Record([src_buffer, vk_image, vk_aspect_mask, was_initialized, + const bool is_initialized = std::exchange(initialized, true); + scheduler->Record([src_buffer, vk_image, vk_aspect_mask, is_initialized, vk_copies](vk::CommandBuffer cmdbuf) { - CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, was_initialized, vk_copies); + CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, is_initialized, vk_copies); }); if (is_rescaled) {