1
0
Fork 0
forked from suyu/suyu
suyu/src/core/crypto/key_manager.h

123 lines
3.7 KiB
C++
Raw Normal View History

2018-07-28 05:55:23 +02:00
// Copyright 2018 yuzu emulator team
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
2018-07-28 05:55:23 +02:00
#include <array>
#include <string>
#include <boost/container/flat_map.hpp>
#include <boost/optional.hpp>
2018-07-28 20:28:14 +02:00
#include <fmt/format.h>
2018-07-28 05:55:23 +02:00
#include "common/common_types.h"
namespace Loader {
enum class ResultStatus : u16;
}
2018-07-28 05:55:23 +02:00
namespace Core::Crypto {
2018-07-28 05:55:23 +02:00
constexpr u64 TICKET_FILE_TITLEKEY_OFFSET = 0x180;
using Key128 = std::array<u8, 0x10>;
using Key256 = std::array<u8, 0x20>;
using SHA256Hash = std::array<u8, 0x20>;
2018-07-28 05:55:23 +02:00
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, //
SDKeySource, // f1=SDKeyType
2018-07-28 05:55:23 +02:00
};
enum class S128KeyType : u64 {
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
Source, // f1=source type, f2= sub id
2018-07-28 05:55:23 +02:00
};
enum class KeyAreaKeyType : u8 {
Application,
Ocean,
System,
};
enum class SourceKeyType : u8 {
2018-09-24 02:31:00 +02:00
SDKek, //
AESKekGeneration, //
AESKeyGeneration, //
};
enum class SDKeyType : u8 {
Save,
NCA,
};
2018-07-28 05:55:23 +02:00
template <typename KeyType>
struct KeyIndex {
KeyType type;
u64 field1;
u64 field2;
std::string DebugInfo() const {
2018-07-28 05:55:23 +02:00
u8 key_size = 16;
if constexpr (std::is_same_v<KeyType, S256KeyType>)
2018-07-28 05:55:23 +02:00
key_size = 32;
return fmt::format("key_size={:02X}, key={:02X}, field1={:016X}, field2={:016X}", key_size,
static_cast<u8>(type), field1, field2);
}
};
// boost flat_map requires operator< for O(log(n)) lookups.
template <typename KeyType>
bool operator<(const KeyIndex<KeyType>& lhs, const KeyIndex<KeyType>& rhs) {
return std::tie(lhs.type, lhs.field1, lhs.field2) < std::tie(rhs.type, rhs.field1, rhs.field2);
}
class KeyManager {
public:
KeyManager();
2018-07-28 05:55:23 +02:00
bool HasKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
bool HasKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
2018-07-28 05:55:23 +02:00
Key128 GetKey(S128KeyType id, u64 field1 = 0, u64 field2 = 0) const;
Key256 GetKey(S256KeyType id, u64 field1 = 0, u64 field2 = 0) const;
2018-07-28 05:55:23 +02:00
void SetKey(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
void SetKey(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);
static bool KeyFileExists(bool title);
// Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system save
// 8*43 and the private file to exist.
void DeriveSDSeedLazy();
2018-07-28 05:55:23 +02:00
private:
boost::container::flat_map<KeyIndex<S128KeyType>, Key128> s128_keys;
boost::container::flat_map<KeyIndex<S256KeyType>, Key256> s256_keys;
2018-07-28 05:55:23 +02:00
bool dev_mode;
void LoadFromFile(const std::string& filename, bool is_title_keys);
void AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
const std::string& filename, bool title);
template <std::size_t Size>
void WriteKeyToFile(bool title_key, std::string_view keyname, const std::array<u8, Size>& key);
2018-07-28 05:55:23 +02:00
static const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> s128_file_id;
static const boost::container::flat_map<std::string, KeyIndex<S256KeyType>> s256_file_id;
2018-07-28 05:55:23 +02:00
};
Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed);
boost::optional<Key128> DeriveSDSeed();
Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManager& keys);
} // namespace Core::Crypto