10#include <botan/der_enc.h>
11#include <botan/hash.h>
12#include <botan/mem_ops.h>
13#include <botan/pk_ops.h>
14#include <botan/pk_options_readers.h>
16#include <botan/internal/fmt.h>
17#include <botan/internal/hash_id.h>
18#include <botan/internal/pk_options_impl.h>
19#include <botan/internal/workfactor.h>
22#include <trousers/trousers.h>
23#include <tss/platform.h>
32void tss_error(TSS_RESULT res,
const char* expr,
const char* file,
int line) {
33 std::string err =
fmt(
"TPM error {} in layer {} executing {} at {}:{}",
34 Trspi_Error_String(res),
35 Trspi_Error_Layer(res),
43TSS_FLAG bit_flag(
size_t bits) {
47 return TSS_KEY_SIZE_1024;
49 return TSS_KEY_SIZE_2048;
53 return TSS_KEY_SIZE_4096;
55 return TSS_KEY_SIZE_8192;
57 return TSS_KEY_SIZE_16384;
64uint32_t to_uint32(T v) {
65 BOTAN_ARG_CHECK(v > std::numeric_limits<uint32_t>::max(),
"Value too large for 32bit unsigned integer");
66 return static_cast<uint32_t
>(v);
69#define TSPI_CHECK_SUCCESS(expr) \
71 TSS_RESULT res = expr; \
72 if(res != TSS_SUCCESS) \
73 tss_error(res, #expr, __FILE__, __LINE__); \
76std::vector<uint8_t> get_obj_attr(TSS_HCONTEXT ctx, TSS_HOBJECT obj, TSS_FLAG flag, TSS_FLAG sub_flag) {
81 std::vector<uint8_t> r(data, data + data_len);
88void set_policy_secret(TSS_HPOLICY policy,
const char* secret) {
90 BYTE* as_b =
const_cast<BYTE*
>(
reinterpret_cast<const BYTE*
>(secret));
91 TSPI_CHECK_SUCCESS(::Tspi_Policy_SetSecret(policy, TSS_SECRET_MODE_PLAIN, to_uint32(std::strlen(secret)), as_b));
93 static const uint8_t nullpass[20] = {0};
96 ::Tspi_Policy_SetSecret(policy, TSS_SECRET_MODE_SHA1,
sizeof(nullpass),
const_cast<BYTE*
>(nullpass)));
100TSS_UUID to_tss_uuid(
const UUID& uuid) {
101 static_assert(
sizeof(TSS_UUID) == 16,
"Expected size of packed UUID");
108UUID from_tss_uuid(
const TSS_UUID& tss_uuid) {
109 static_assert(
sizeof(TSS_UUID) == 16,
"Expected size of packed UUID");
111 std::vector<uint8_t> mem(16);
113 UUID uuid(std::move(mem));
118 if(flag == TSS_PS_TYPE_USER)
120 else if(flag == TSS_PS_TYPE_SYSTEM)
123 throw TPM_Error(
"Invalid storage flag " + std::to_string(flag));
128 return "tpmkey:uuid=" + uuid.to_string() +
";storage=" + storage_str;
131std::string format_url(
const TSS_UUID& tss_uuid, TSS_FLAG store_type) {
132 UUID uuid = from_tss_uuid(tss_uuid);
134 return format_url(from_tss_uuid(tss_uuid), storage_type_from_tss_flag(store_type));
145 const TSS_UUID SRK_UUID = TSS_UUID_SRK;
147 TSPI_CHECK_SUCCESS(::Tspi_Context_LoadKeyByUUID(m_ctx, TSS_PS_TYPE_SYSTEM, SRK_UUID, &m_srk));
150 set_policy_secret(m_srk_policy, srk_password);
172 copy_mem(out,
reinterpret_cast<const uint8_t*
>(mem), out_len);
177 TSPI_CHECK_SUCCESS(::Tspi_TPM_StirRandom(m_tpm, to_uint32(in_len),
const_cast<BYTE*
>(in)));
184 TSS_FLAG key_flags = bit_flag(bits) | TSS_KEY_VOLATILE | TSS_KEY_TYPE_SIGNING;
187 TSPI_CHECK_SUCCESS(::Tspi_Context_CreateObject(m_ctx.handle(), TSS_OBJECT_TYPE_RSAKEY, key_flags, &key));
190 ::Tspi_SetAttribUint32(key, TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_SIGSCHEME, TSS_SS_RSASSAPKCS1V15_DER));
193 TSPI_CHECK_SUCCESS(::Tspi_Context_CreateObject(m_ctx.handle(), TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &policy));
194 set_policy_secret(policy, key_password);
203 m_ctx(
ctx), m_uuid(uuid_str), m_storage(storage_type) {
204 const TSS_FLAG key_ps_type = (m_storage ==
TPM_Storage_Type::User) ? TSS_PS_TYPE_USER : TSS_PS_TYPE_SYSTEM;
206 TSPI_CHECK_SUCCESS(::Tspi_Context_LoadKeyByUUID(m_ctx.handle(), key_ps_type, to_tss_uuid(m_uuid), &m_key));
211 m_ctx.handle(), m_ctx.srk(), to_uint32(blob.size()),
const_cast<uint8_t*
>(blob.data()), &m_key));
217 if(!m_uuid.is_valid()) {
220 m_storage = storage_type;
222 const TSS_UUID key_uuid = to_tss_uuid(m_uuid);
223 const TSS_FLAG key_ps_type = (storage_type ==
TPM_Storage_Type::User) ? TSS_PS_TYPE_USER : TSS_PS_TYPE_SYSTEM;
225 const TSS_UUID srk_uuid = TSS_UUID_SRK;
228 ::Tspi_Context_RegisterKey(m_ctx.handle(), m_key, key_ps_type, key_uuid, TSS_PS_TYPE_SYSTEM, srk_uuid));
233 if(storage_type != m_storage) {
234 throw TPM_Error(
"TPM key " + m_uuid.to_string() +
" already registered with different storage type");
237 return format_url(m_uuid, m_storage);
241 TSS_KM_KEYINFO2* key_info;
242 UINT32 key_info_size;
246 ::Tspi_Context_GetRegisteredKeysByUUID2(
ctx.handle(), TSS_PS_TYPE_SYSTEM,
nullptr, &key_info_size, &key_info));
248 std::vector<std::string> r(key_info_size);
250 for(
size_t i = 0; i != key_info_size; ++i) {
251 r[i] = format_url(key_info[i].keyUUID, key_info[i].persistentStorageType);
263 get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_MODULUS));
272 get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_EXPONENT));
291 std::vector<uint8_t> bits;
297 throw TPM_Error(
"Raw public key export not supported for RSA TPM keys");
301 throw TPM_Error(
"Private key export not supported for TPM keys");
305 return get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_KEY_BLOB, TSS_TSPATTRIB_KEYBLOB_BLOB);
309 return std::make_unique<RSA_PublicKey>(
get_n(),
get_e());
320 TPM_Signing_Operation(
const TPM_PrivateKey& key, std::string_view hash_name) :
323 std::string hash_function()
const override {
return m_hash->name(); }
325 size_t signature_length()
const override {
return m_key.get_n().bytes(); }
327 void update(std::span<const uint8_t> msg)
override { m_hash->update(msg); }
329 AlgorithmIdentifier algorithm_identifier()
const override {
330 const std::string full_name =
"RSA/EMSA3(" + m_hash->name() +
")";
335 std::vector<uint8_t> sign(RandomNumberGenerator&)
override {
345 std::vector<uint8_t> id_and_msg;
346 id_and_msg.reserve(m_hash_id.size() + msg_hash.size());
347 id_and_msg.insert(id_and_msg.end(), m_hash_id.begin(), m_hash_id.end());
348 id_and_msg.insert(id_and_msg.end(), msg_hash.begin(), msg_hash.end());
350 TSS_HCONTEXT ctx = m_key.ctx().handle();
352 TSPI_CHECK_SUCCESS(::Tspi_Context_CreateObject(ctx, TSS_OBJECT_TYPE_HASH, TSS_HASH_OTHER, &tpm_hash));
353 TSPI_CHECK_SUCCESS(::Tspi_Hash_SetHashValue(tpm_hash, to_uint32(id_and_msg.size()), id_and_msg.data()));
355 BYTE* sig_bytes =
nullptr;
358 std::vector<uint8_t> sig(sig_bytes, sig_bytes + sig_len);
370 const TPM_PrivateKey m_key;
371 std::unique_ptr<HashFunction> m_hash;
372 std::vector<uint8_t> m_hash_id;
#define BOTAN_ARG_CHECK(expr, msg)
virtual OID object_identifier() const
static BigInt from_bytes(std::span< const uint8_t > bytes)
DER_Encoder & start_sequence()
DER_Encoder & encode(bool b)
static OID from_string(std::string_view str)
const std::optional< std::string > & padding() const
bool using_padding() const
const std::string & hash_function_name() const
TPM_Context(pin_cb cb, const char *srk_password)
void gen_random(uint8_t out[], size_t out_len)
uint32_t current_counter()
std::function< std::string(std::string)> pin_cb
void stir_random(const uint8_t in[], size_t in_len)
std::vector< uint8_t > export_blob() const
std::vector< uint8_t > raw_public_key_bits() const override
std::string register_key(TPM_Storage_Type storage_type)
TPM_PrivateKey(TPM_Context &ctx, size_t bits, const char *key_password)
secure_vector< uint8_t > private_key_bits() const override
static std::vector< std::string > registered_keys(TPM_Context &ctx)
bool check_key(RandomNumberGenerator &rng, bool) const override
TPM_Context & ctx() const
size_t key_length() const override
std::vector< uint8_t > public_key_bits() const override
size_t estimated_strength() const override
std::string algo_name() const override
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
std::unique_ptr< Public_Key > public_key() const override
AlgorithmIdentifier algorithm_identifier() const override
void require_hardware_provider(const OptionsT &options, std::string_view algo_name, std::string_view provider_name)
std::string fmt(std::string_view format, const T &... args)
void acknowledge_always_deterministic(const PK_Signature_Options_Reader &options)
constexpr void typecast_copy(ToR &&out, const FromR &in)
constexpr void copy_mem(T *out, const T *in, size_t n)
std::vector< uint8_t > pkcs_hash_id(std::string_view name)
std::vector< T, secure_allocator< T > > secure_vector
size_t if_work_factor(size_t bits)
#define TSPI_CHECK_SUCCESS(expr)