Botan 3.14.1
Crypto and TLS for C&
tpm.cpp
Go to the documentation of this file.
1/*
2* TPM 1.2 interface
3* (C) 2015 Jack Lloyd
4*
5* Botan is released under the Simplified BSD License (see license.txt)
6*/
7
8#include <botan/tpm.h>
9
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>
15#include <botan/rsa.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>
20#include <limits>
21
22#include <trousers/trousers.h>
23#include <tss/platform.h>
24#include <tss/tspi.h>
25
26// TODO: dynamically load the TPM libraries?
27
28namespace Botan {
29
30namespace {
31
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),
36 expr,
37 line,
38 file);
39
40 throw TPM_Error(err);
41}
42
43TSS_FLAG bit_flag(size_t bits) {
44 switch(bits) {
45 // 512 supported, but ignored and rejected here
46 case 1024:
47 return TSS_KEY_SIZE_1024;
48 case 2048:
49 return TSS_KEY_SIZE_2048;
50
51 // Most? v1.2 TPMs only support 1024 and 2048 bit keys ...
52 case 4096:
53 return TSS_KEY_SIZE_4096;
54 case 8192:
55 return TSS_KEY_SIZE_8192;
56 case 16384:
57 return TSS_KEY_SIZE_16384;
58 default:
59 throw Invalid_Argument("Unsupported TPM key size " + std::to_string(bits));
60 }
61}
62
63template <typename T>
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);
67}
68
69#define TSPI_CHECK_SUCCESS(expr) \
70 do { \
71 TSS_RESULT res = expr; \
72 if(res != TSS_SUCCESS) \
73 tss_error(res, #expr, __FILE__, __LINE__); \
74 } while(0)
75
76std::vector<uint8_t> get_obj_attr(TSS_HCONTEXT ctx, TSS_HOBJECT obj, TSS_FLAG flag, TSS_FLAG sub_flag) {
77 BYTE* data = nullptr;
78 UINT32 data_len = 0;
79 TSPI_CHECK_SUCCESS(::Tspi_GetAttribData(obj, flag, sub_flag, &data_len, &data));
80
81 std::vector<uint8_t> r(data, data + data_len);
82
83 TSPI_CHECK_SUCCESS(::Tspi_Context_FreeMemory(ctx, data));
84
85 return r;
86}
87
88void set_policy_secret(TSS_HPOLICY policy, const char* secret) {
89 if(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));
92 } else {
93 static const uint8_t nullpass[20] = {0};
94
96 ::Tspi_Policy_SetSecret(policy, TSS_SECRET_MODE_SHA1, sizeof(nullpass), const_cast<BYTE*>(nullpass)));
97 }
98}
99
100TSS_UUID to_tss_uuid(const UUID& uuid) {
101 static_assert(sizeof(TSS_UUID) == 16, "Expected size of packed UUID");
102
103 TSS_UUID tss_uuid;
104 typecast_copy(tss_uuid, uuid.binary_value().data());
105 return tss_uuid;
106}
107
108UUID from_tss_uuid(const TSS_UUID& tss_uuid) {
109 static_assert(sizeof(TSS_UUID) == 16, "Expected size of packed UUID");
110
111 std::vector<uint8_t> mem(16);
112 typecast_copy(mem.data(), tss_uuid);
113 UUID uuid(std::move(mem));
114 return uuid;
115}
116
117TPM_Storage_Type storage_type_from_tss_flag(TSS_FLAG flag) {
118 if(flag == TSS_PS_TYPE_USER)
120 else if(flag == TSS_PS_TYPE_SYSTEM)
122 else
123 throw TPM_Error("Invalid storage flag " + std::to_string(flag));
124}
125
126std::string format_url(const UUID& uuid, TPM_Storage_Type storage) {
127 std::string storage_str = (storage == TPM_Storage_Type::User) ? "user" : "system";
128 return "tpmkey:uuid=" + uuid.to_string() + ";storage=" + storage_str;
129}
130
131std::string format_url(const TSS_UUID& tss_uuid, TSS_FLAG store_type) {
132 UUID uuid = from_tss_uuid(tss_uuid);
133
134 return format_url(from_tss_uuid(tss_uuid), storage_type_from_tss_flag(store_type));
135}
136
137} // namespace
138
139TPM_Context::TPM_Context(pin_cb cb, const char* srk_password) : m_pin_cb(cb), m_srk_policy(0) {
140 TSPI_CHECK_SUCCESS(::Tspi_Context_Create(&m_ctx));
141 TSPI_CHECK_SUCCESS(::Tspi_Context_Connect(m_ctx, nullptr));
142
143 TSPI_CHECK_SUCCESS(::Tspi_Context_GetTpmObject(m_ctx, &m_tpm));
144
145 const TSS_UUID SRK_UUID = TSS_UUID_SRK;
146
147 TSPI_CHECK_SUCCESS(::Tspi_Context_LoadKeyByUUID(m_ctx, TSS_PS_TYPE_SYSTEM, SRK_UUID, &m_srk));
148
149 TSPI_CHECK_SUCCESS(::Tspi_GetPolicyObject(m_srk, TSS_POLICY_USAGE, &m_srk_policy));
150 set_policy_secret(m_srk_policy, srk_password);
151
152 // TODO: do we have to cache it?
153 // TODO: try to use SRK with null, if it fails call the pin cb?
154}
155
157 TSPI_CHECK_SUCCESS(::Tspi_Context_CloseObject(m_ctx, m_srk));
158 //TSPI_CHECK_SUCCESS(::Tspi_Context_CloseObject(m_ctx, m_tpm));
159 TSPI_CHECK_SUCCESS(::Tspi_Context_Close(m_srk_policy));
160 TSPI_CHECK_SUCCESS(::Tspi_Context_Close(m_ctx));
161}
162
164 uint32_t r = 0;
165 TSPI_CHECK_SUCCESS(::Tspi_TPM_ReadCounter(m_tpm, &r));
166 return r;
167}
168
169void TPM_Context::gen_random(uint8_t out[], size_t out_len) {
170 BYTE* mem;
171 TSPI_CHECK_SUCCESS(::Tspi_TPM_GetRandom(m_tpm, to_uint32(out_len), &mem));
172 copy_mem(out, reinterpret_cast<const uint8_t*>(mem), out_len);
173 TSPI_CHECK_SUCCESS(::Tspi_Context_FreeMemory(m_ctx, mem));
174}
175
176void TPM_Context::stir_random(const uint8_t in[], size_t in_len) {
177 TSPI_CHECK_SUCCESS(::Tspi_TPM_StirRandom(m_tpm, to_uint32(in_len), const_cast<BYTE*>(in)));
178}
179
180TPM_PrivateKey::TPM_PrivateKey(TPM_Context& ctx, size_t bits, const char* key_password) : m_ctx(ctx) {
181 // TODO: can also do OAEP decryption via binding keys
182 // TODO: offer signing, binding (decrypt), or legacy (sign + decrypt) keys?
183
184 TSS_FLAG key_flags = bit_flag(bits) | TSS_KEY_VOLATILE | TSS_KEY_TYPE_SIGNING;
185
186 TSS_HKEY key;
187 TSPI_CHECK_SUCCESS(::Tspi_Context_CreateObject(m_ctx.handle(), TSS_OBJECT_TYPE_RSAKEY, key_flags, &key));
188
190 ::Tspi_SetAttribUint32(key, TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_SIGSCHEME, TSS_SS_RSASSAPKCS1V15_DER));
191
192 TSS_HPOLICY policy;
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);
195 TSPI_CHECK_SUCCESS(::Tspi_Policy_AssignToObject(policy, key));
196
197 TSPI_CHECK_SUCCESS(::Tspi_Key_CreateKey(key, ctx.srk(), 0));
198 m_key = key;
199}
200
201// reference a registered TPM key
202TPM_PrivateKey::TPM_PrivateKey(TPM_Context& ctx, std::string_view uuid_str, TPM_Storage_Type storage_type) :
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;
205
206 TSPI_CHECK_SUCCESS(::Tspi_Context_LoadKeyByUUID(m_ctx.handle(), key_ps_type, to_tss_uuid(m_uuid), &m_key));
207}
208
209TPM_PrivateKey::TPM_PrivateKey(TPM_Context& ctx, const std::vector<uint8_t>& blob) : m_ctx(ctx) {
210 TSPI_CHECK_SUCCESS(::Tspi_Context_LoadKeyByBlob(
211 m_ctx.handle(), m_ctx.srk(), to_uint32(blob.size()), const_cast<uint8_t*>(blob.data()), &m_key));
212
213 //TSPI_CHECK_SUCCESS(::Tspi_Key_LoadKey(m_key, m_ctx.srk()));
214}
215
217 if(!m_uuid.is_valid()) {
218 TPM_RNG rng(ctx()); // use system_rng or arg RNG& instead?
219 m_uuid = UUID(rng);
220 m_storage = storage_type;
221
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;
224
225 const TSS_UUID srk_uuid = TSS_UUID_SRK;
226
228 ::Tspi_Context_RegisterKey(m_ctx.handle(), m_key, key_ps_type, key_uuid, TSS_PS_TYPE_SYSTEM, srk_uuid));
229 }
230
231 // Presumably we could re-register in the other store and same UUID
232 // Doesn't seem like what is desired most of the time here
233 if(storage_type != m_storage) {
234 throw TPM_Error("TPM key " + m_uuid.to_string() + " already registered with different storage type");
235 }
236
237 return format_url(m_uuid, m_storage);
238}
239
241 TSS_KM_KEYINFO2* key_info;
242 UINT32 key_info_size;
243
244 // TODO: does the PS type matter here at all?
246 ::Tspi_Context_GetRegisteredKeysByUUID2(ctx.handle(), TSS_PS_TYPE_SYSTEM, nullptr, &key_info_size, &key_info));
247
248 std::vector<std::string> r(key_info_size);
249
250 for(size_t i = 0; i != key_info_size; ++i) {
251 r[i] = format_url(key_info[i].keyUUID, key_info[i].persistentStorageType);
252 }
253
254 // TODO: are we supposed to free this memory and if so how?
255 //TSPI_CHECK_SUCCESS(::Tspi_Context_FreeMemory(ctx.handle(), key_info));
256
257 return r;
258}
259
261 if(m_n == 0) {
262 m_n = BigInt::from_bytes(
263 get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_MODULUS));
264 }
265
266 return m_n;
267}
268
270 if(m_e == 0) {
271 m_e = BigInt::from_bytes(
272 get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_RSAKEY_INFO, TSS_TSPATTRIB_KEYINFO_RSA_EXPONENT));
273 }
274
275 return m_e;
276}
277
281
283 return get_n().bits();
284}
285
289
290std::vector<uint8_t> TPM_PrivateKey::public_key_bits() const {
291 std::vector<uint8_t> bits;
293 return bits;
294}
295
296std::vector<uint8_t> TPM_PrivateKey::raw_public_key_bits() const {
297 throw TPM_Error("Raw public key export not supported for RSA TPM keys");
298}
299
301 throw TPM_Error("Private key export not supported for TPM keys");
302}
303
304std::vector<uint8_t> TPM_PrivateKey::export_blob() const {
305 return get_obj_attr(m_ctx.handle(), m_key, TSS_TSPATTRIB_KEY_BLOB, TSS_TSPATTRIB_KEYBLOB_BLOB);
306}
307
308std::unique_ptr<Public_Key> TPM_PrivateKey::public_key() const {
309 return std::make_unique<RSA_PublicKey>(get_n(), get_e());
310}
311
313 return true; // TODO do a kat or pairwise check
314}
315
316namespace {
317
318class TPM_Signing_Operation final : public PK_Ops::Signature {
319 public:
320 TPM_Signing_Operation(const TPM_PrivateKey& key, std::string_view hash_name) :
321 m_key(key), m_hash(HashFunction::create_or_throw(hash_name)), m_hash_id(pkcs_hash_id(hash_name)) {}
322
323 std::string hash_function() const override { return m_hash->name(); }
324
325 size_t signature_length() const override { return m_key.get_n().bytes(); }
326
327 void update(std::span<const uint8_t> msg) override { m_hash->update(msg); }
328
329 AlgorithmIdentifier algorithm_identifier() const override {
330 const std::string full_name = "RSA/EMSA3(" + m_hash->name() + ")";
331 const OID oid = OID::from_string(full_name);
332 return AlgorithmIdentifier(oid, AlgorithmIdentifier::USE_EMPTY_PARAM);
333 }
334
335 std::vector<uint8_t> sign(RandomNumberGenerator&) override {
336 /*
337 * v1.2 TPMs will only sign with PKCS #1 v1.5 padding. SHA-1 is built
338 * in, all other hash inputs (TSS_HASH_OTHER) are treated as the
339 * concatenation of the hash OID and hash value and signed with just the
340 * 01FFFF... prefix. Even when using SHA-1 we compute the hash locally
341 * since it is going to be much faster than pushing data over the LPC bus.
342 */
343 secure_vector<uint8_t> msg_hash = m_hash->final();
344
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());
349
350 TSS_HCONTEXT ctx = m_key.ctx().handle();
351 TSS_HHASH tpm_hash;
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()));
354
355 BYTE* sig_bytes = nullptr;
356 UINT32 sig_len = 0;
357 TSPI_CHECK_SUCCESS(::Tspi_Hash_Sign(tpm_hash, m_key.handle(), &sig_len, &sig_bytes));
358 std::vector<uint8_t> sig(sig_bytes, sig_bytes + sig_len);
359
360 // TODO: RAII for Context_FreeMemory
361 TSPI_CHECK_SUCCESS(::Tspi_Context_FreeMemory(ctx, sig_bytes));
362
363 // TODO: RAII for Context_CloseObject
364 TSPI_CHECK_SUCCESS(::Tspi_Context_CloseObject(ctx, tpm_hash));
365
366 return sig;
367 }
368
369 private:
370 const TPM_PrivateKey m_key;
371 std::unique_ptr<HashFunction> m_hash;
372 std::vector<uint8_t> m_hash_id;
373};
374
375} // namespace
376
377std::unique_ptr<PK_Ops::Signature> TPM_PrivateKey::_create_signature_op(
378 RandomNumberGenerator& rng, const PK_Signature_Options_Reader& options) const {
379 BOTAN_UNUSED(rng);
380 require_hardware_provider(options, algo_name(), "tpm");
381 // Historically only a hash was specified, in which case PKCS1v15 is implied
382 if(options.using_padding() && options.padding().value() != "PKCS1v15") {
383 throw Invalid_Argument("TPMv1 can only sign using PKCS1v15 padding");
384 }
386 return std::make_unique<TPM_Signing_Operation>(*this, options.hash_function_name());
387}
388
389} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
virtual OID object_identifier() const
Definition pk_keys.cpp:24
static BigInt from_bytes(std::span< const uint8_t > bytes)
Definition bigint.cpp:84
size_t bits() const
Definition bigint.cpp:308
DER_Encoder & start_sequence()
Definition der_enc.h:86
DER_Encoder & end_cons()
Definition der_enc.cpp:208
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
static OID from_string(std::string_view str)
Definition asn1_oid.cpp:80
const std::optional< std::string > & padding() const
const std::string & hash_function_name() const
TPM_Context(pin_cb cb, const char *srk_password)
Definition tpm.cpp:139
void gen_random(uint8_t out[], size_t out_len)
Definition tpm.cpp:169
uint32_t current_counter()
Definition tpm.cpp:163
std::function< std::string(std::string)> pin_cb
Definition tpm.h:49
void stir_random(const uint8_t in[], size_t in_len)
Definition tpm.cpp:176
std::vector< uint8_t > export_blob() const
Definition tpm.cpp:304
std::vector< uint8_t > raw_public_key_bits() const override
Definition tpm.cpp:296
std::string register_key(TPM_Storage_Type storage_type)
Definition tpm.cpp:216
TPM_PrivateKey(TPM_Context &ctx, size_t bits, const char *key_password)
Definition tpm.cpp:180
secure_vector< uint8_t > private_key_bits() const override
Definition tpm.cpp:300
static std::vector< std::string > registered_keys(TPM_Context &ctx)
Definition tpm.cpp:240
bool check_key(RandomNumberGenerator &rng, bool) const override
Definition tpm.cpp:312
TPM_Context & ctx() const
Definition tpm.h:140
BigInt get_e() const
Definition tpm.cpp:269
size_t key_length() const override
Definition tpm.cpp:282
std::vector< uint8_t > public_key_bits() const override
Definition tpm.cpp:290
size_t estimated_strength() const override
Definition tpm.cpp:278
std::string algo_name() const override
Definition tpm.h:167
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
Definition tpm.cpp:377
std::unique_ptr< Public_Key > public_key() const override
Definition tpm.cpp:308
BigInt get_n() const
Definition tpm.cpp:260
AlgorithmIdentifier algorithm_identifier() const override
Definition tpm.cpp:286
void require_hardware_provider(const OptionsT &options, std::string_view algo_name, std::string_view provider_name)
TPM_Storage_Type
Definition tpm.h:102
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
void acknowledge_always_deterministic(const PK_Signature_Options_Reader &options)
constexpr void typecast_copy(ToR &&out, const FromR &in)
Definition mem_ops.h:176
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:144
std::vector< uint8_t > pkcs_hash_id(std::string_view name)
Definition hash_id.cpp:78
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
size_t if_work_factor(size_t bits)
#define TSPI_CHECK_SUCCESS(expr)
Definition tpm.cpp:69