diff --git a/src/core/crypto/key_manager.cpp b/src/core/crypto/key_manager.cpp index 6d0b32ba70..50945eee91 100644 --- a/src/core/crypto/key_manager.cpp +++ b/src/core/crypto/key_manager.cpp @@ -45,13 +45,6 @@ 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", @@ -1117,81 +1110,25 @@ void KeyManager::DeriveBase() { void KeyManager::DeriveETicket(PartitionDataManager& data, const FileSys::ContentProvider& provider) { - // ETicket keys - const auto es = provider.GetEntry(0x0100000000000033, FileSys::ContentRecordType::Program); - - if (es == nullptr) { + // 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."); return; } - 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 + // Decrypt PRODINFO to get the extended kek needed for the RSA keypair. 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(); } @@ -1272,22 +1209,6 @@ 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()); } @@ -1302,13 +1223,6 @@ 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()) @@ -1322,27 +1236,6 @@ 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 8e4fc2e595..e185838e57 100644 --- a/src/core/crypto/partition_data_manager.cpp +++ b/src/core/crypto/partition_data_manager.cpp @@ -4,11 +4,6 @@ // 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 @@ -49,178 +44,7 @@ struct Package2Header { }; static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size."); -// 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; -} +const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = 32; static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir, const std::string& name) { @@ -287,52 +111,10 @@ 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; } @@ -444,46 +226,10 @@ 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; } @@ -509,4 +255,4 @@ std::array PartitionDataManager::GetETicketExtendedKek() const { prodinfo_decrypted->Read(out.data(), out.size(), 0x3890); return out; } -} // namespace Core::Crypto +} // namespace Core::Crypto \ No newline at end of file diff --git a/src/core/crypto/partition_data_manager.h b/src/core/crypto/partition_data_manager.h index 4354a21e6a..2a01aed228 100644 --- a/src/core/crypto/partition_data_manager.h +++ b/src/core/crypto/partition_data_manager.h @@ -1,3 +1,6 @@ +// 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 @@ -36,16 +39,7 @@ 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; @@ -63,21 +57,8 @@ 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; @@ -104,6 +85,4 @@ private: std::array, 6> package2_spl; }; -std::array FindKeyFromHex16(const std::vector& binary, std::array hash); - -} // namespace Core::Crypto +} // namespace Core::Crypto \ No newline at end of file diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp index fb5157a658..7befe235c4 100644 --- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp @@ -1377,17 +1377,13 @@ 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)) { - - 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}; + 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()); @@ -1565,10 +1561,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 && + (aspect_mask & VK_IMAGE_ASPECT_COLOR_BIT) != 0 && runtime->CanUploadMSAA() && runtime->msaa_copy_pass != nullptr && runtime->device.IsStorageImageMultisampleSupported(); @@ -1578,7 +1574,8 @@ 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; @@ -1588,7 +1585,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 = VK_IMAGE_ASPECT_COLOR_BIT; + temp_wrapper->aspect_mask = aspect_mask; temp_wrapper->initialized = true; // Upload to the temporary non-MSAA image @@ -1597,18 +1594,17 @@ 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; @@ -1621,11 +1617,9 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset, /*msaa_to_non_msaa=*/false); std::exchange(initialized, true); - // 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) {}); + const u64 tick = scheduler->Flush(); + scheduler->Wait(tick); - // CHANGE: Restore scaling before returning from the MSAA path. if (is_rescaled) { ScaleUp(); } @@ -1638,10 +1632,11 @@ 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 is_initialized = std::exchange(initialized, true); - scheduler->Record([src_buffer, vk_image, vk_aspect_mask, is_initialized, + const bool was_initialized = std::exchange(initialized, true); + + scheduler->Record([src_buffer, vk_image, vk_aspect_mask, was_initialized, vk_copies](vk::CommandBuffer cmdbuf) { - CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, is_initialized, vk_copies); + CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, was_initialized, vk_copies); }); if (is_rescaled) {