Botan 3.14.1
Crypto and TLS for C&
tpm2_key.cpp
Go to the documentation of this file.
1/*
2* TPM 2.0 Key Wrappers' Base Class
3* (C) 2024 Jack Lloyd
4* (C) 2024 René Meusel, Amos Treiber - Rohde & Schwarz Cybersecurity GmbH, financed by LANCOM Systems GmbH
5*
6* Botan is released under the Simplified BSD License (see license.txt)
7*/
8
9#include <botan/tpm2_key.h>
10
11#if defined(BOTAN_HAS_TPM2_RSA_ADAPTER)
12 #include <botan/tpm2_rsa.h>
13#endif
14#if defined(BOTAN_HAS_TPM2_ECC_ADAPTER)
15 #include <botan/tpm2_ecc.h>
16#endif
17
18#include <botan/internal/concat_util.h>
19#include <botan/internal/fmt.h>
20#include <botan/internal/stl_util.h>
21#include <botan/internal/tpm2_algo_mappings.h>
22#include <botan/internal/tpm2_util.h>
23
24#include <tss2/tss2_esys.h>
25#include <tss2/tss2_mu.h>
26
27namespace Botan::TPM2 {
28
29#if defined(BOTAN_HAS_RSA)
30Botan::RSA_PublicKey rsa_pubkey_from_tss2_public(const TPM2B_PUBLIC* public_area) {
31 // TODO: this RSA_PublicKey currently takes const-refs, so we cannot benefit
32 // from moving them in place. This should be fixed in the future.
33 return std::apply([](const BigInt& n, const BigInt& e) { return Botan::RSA_PublicKey(n, e); },
34 rsa_pubkey_components_from_tss2_public(public_area));
35}
36#endif
37
38#if defined(BOTAN_HAS_ECC_GROUP)
39std::pair<EC_Group, EC_AffinePoint> ecc_pubkey_from_tss2_public(const TPM2B_PUBLIC* public_blob) {
40 BOTAN_ASSERT_NONNULL(public_blob);
41 BOTAN_ARG_CHECK(public_blob->publicArea.type == TPM2_ALG_ECC, "Public blob is not an ECC key");
42
43 const auto curve_id = public_blob->publicArea.parameters.eccDetail.curveID;
44 const auto curve_name = curve_id_tss2_to_botan(curve_id);
45 if(!curve_name) {
46 throw Invalid_Argument(Botan::fmt("Unsupported ECC curve: {}", curve_id));
47 }
48
49 auto curve = Botan::EC_Group::from_name(curve_name.value());
50 // Create an EC_AffinePoint from the x and y coordinates as SEC1 uncompressed point.
51 // According to the TPM2.0 specification Part 1 C.8, each coordinate is already padded to the curve's size.
52
54 curve,
55 concat<std::vector<uint8_t>>(std::array<uint8_t, 1>{0x04},
56 as_span(public_blob->publicArea.unique.ecc.x),
57 as_span(public_blob->publicArea.unique.ecc.y)));
58
59 if(!point) {
60 throw Invalid_Argument("Invalid ECC Point");
61 }
62 return {std::move(curve), std::move(point.value())};
63}
64#endif
65
66namespace {
67
68Object load_persistent_object(const std::shared_ptr<Context>& ctx,
69 TPM2_HANDLE persistent_object_handle,
70 std::span<const uint8_t> auth_value,
71 const SessionBundle& sessions) {
73 TPM2_PERSISTENT_FIRST <= persistent_object_handle && persistent_object_handle <= TPM2_PERSISTENT_LAST,
74 "persistent_object_handle out of range");
76 const bool is_persistent = value_exists(ctx->persistent_handles(), persistent_object_handle);
77 BOTAN_STATE_CHECK(is_persistent);
78
79 Object object(ctx);
80
81 check_rc("Esys_TR_FromTPMPublic",
82 Esys_TR_FromTPMPublic(ctx->esys_context(),
83 persistent_object_handle,
84 sessions[0],
85 sessions[1],
86 sessions[2],
87 out_transient_handle(object)));
88
89 if(!auth_value.empty()) {
90 const auto user_auth = copy_into<TPM2B_AUTH>(auth_value);
91 check_rc("Esys_TR_SetAuth", Esys_TR_SetAuth(ctx->esys_context(), object.transient_handle(), &user_auth));
92 }
93
94 check_rc("Esys_TR_GetTpmHandle",
95 Esys_TR_GetTpmHandle(ctx->esys_context(), object.transient_handle(), out_persistent_handle(object)));
96
97 const auto key_type = object._public_info(sessions).pub->publicArea.type;
98 BOTAN_ARG_CHECK(key_type == TPM2_ALG_RSA || key_type == TPM2_ALG_ECC,
99 "persistent object is neither RSA nor ECC public key");
100
101 return object;
102}
103
104std::vector<uint8_t> marshal_public_blob(const TPM2B_PUBLIC* public_data) {
105 size_t bytes_required = 0;
106 std::vector<uint8_t> marshalled_blob(sizeof(TPM2B_PUBLIC));
107 check_rc("Tss2_MU_TPM2B_PUBLIC_Marshal",
108 Tss2_MU_TPM2B_PUBLIC_Marshal(public_data, marshalled_blob.data(), marshalled_blob.size(), &bytes_required));
109 marshalled_blob.resize(bytes_required);
110 marshalled_blob.shrink_to_fit();
111 return marshalled_blob;
112}
113
114TPM2B_PUBLIC unmarshal_public_blob(std::span<const uint8_t> marshalled_blob) {
115 TPM2B_PUBLIC public_data{};
116 size_t offset = 0;
117 check_rc("Tss2_MU_TPM2B_PUBLIC_Unmarshal",
118 Tss2_MU_TPM2B_PUBLIC_Unmarshal(marshalled_blob.data(), marshalled_blob.size(), &offset, &public_data));
119 BOTAN_ASSERT_NOMSG(offset == marshalled_blob.size());
120 return public_data;
121}
122
123TPM2B_TEMPLATE marshal_template(const TPMT_PUBLIC& key_template) {
124 TPM2B_TEMPLATE result = {};
125 size_t offset = 0;
126 check_rc("Tss2_MU_TPMT_PUBLIC_Marshal",
127 Tss2_MU_TPMT_PUBLIC_Marshal(&key_template, result.buffer, sizeof(TPMT_PUBLIC), &offset));
128 BOTAN_ASSERT_NOMSG(offset <= sizeof(result.buffer));
129 result.size = static_cast<uint16_t>(offset);
130 return result;
131}
132
133} // namespace
134
135std::unique_ptr<PublicKey> PublicKey::load_persistent(const std::shared_ptr<Context>& ctx,
136 TPM2_HANDLE persistent_object_handle,
137 const SessionBundle& sessions) {
138 return create(load_persistent_object(ctx, persistent_object_handle, {}, sessions), sessions);
139}
140
141std::unique_ptr<PublicKey> PublicKey::load_transient(const std::shared_ptr<Context>& ctx,
142 std::span<const uint8_t> public_blob,
143 const SessionBundle& sessions) {
144 const auto public_data = unmarshal_public_blob(public_blob);
145
147
148 Object handle(ctx);
149 check_rc("Esys_LoadExternal",
150 Esys_LoadExternal(ctx->esys_context(),
151 sessions[0],
152 sessions[1],
153 sessions[2],
154 nullptr /* no private data to be loaded */,
155 &public_data,
156 TPM2_RH_NULL,
157 out_transient_handle(handle)));
158 return create(std::move(handle), sessions);
159}
160
161std::vector<uint8_t> PublicKey::raw_public_key_bits() const {
162 return marshal_public_blob(m_handle._public_info(m_sessions).pub.get());
163}
164
165std::unique_ptr<PublicKey> PublicKey::create(Object handles, const SessionBundle& sessions) {
166 [[maybe_unused]] const auto* pubinfo = handles._public_info(sessions).pub.get();
167#if defined(BOTAN_HAS_TPM2_RSA_ADAPTER)
168 if(pubinfo->publicArea.type == TPM2_ALG_RSA) {
169 return std::unique_ptr<PublicKey>(new RSA_PublicKey(std::move(handles), sessions, pubinfo));
170 }
171#endif
172#if defined(BOTAN_HAS_TPM2_ECC_ADAPTER)
173 if(pubinfo->publicArea.type == TPM2_ALG_ECC) {
174 return std::unique_ptr<PublicKey>(new EC_PublicKey(std::move(handles), sessions, pubinfo));
175 }
176#endif
177
178 throw Not_Implemented(Botan::fmt("Loaded a {} public key of an unsupported type",
179 handles.has_persistent_handle() ? "persistent" : "transient"));
180}
181
182// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
183
184std::unique_ptr<PrivateKey> PrivateKey::load_persistent(const std::shared_ptr<Context>& ctx,
185 TPM2_HANDLE persistent_object_handle,
186 std::span<const uint8_t> auth_value,
187 const SessionBundle& sessions) {
188 return create(load_persistent_object(ctx, persistent_object_handle, auth_value, sessions),
189 sessions,
190 nullptr /* pull public info from handle */,
191 {} /* persistent keys don't have an encrypted private blob */);
192}
193
194std::unique_ptr<PrivateKey> PrivateKey::load_transient(const std::shared_ptr<Context>& ctx,
195 std::span<const uint8_t> auth_value,
196 const TPM2::PrivateKey& parent,
197 std::span<const uint8_t> public_blob,
198 std::span<const uint8_t> private_blob,
199 const SessionBundle& sessions) {
201 Object handle(ctx);
202
203 const auto public_data = unmarshal_public_blob(public_blob);
204 const auto private_data = copy_into<TPM2B_PRIVATE>(private_blob);
205
206 check_rc("Esys_Load",
207 Esys_Load(ctx->esys_context(),
208 parent.handles().transient_handle(),
209 sessions[0],
210 sessions[1],
211 sessions[2],
212 &private_data,
213 &public_data,
214 out_transient_handle(handle)));
215
216 if(!auth_value.empty()) {
217 const auto user_auth = copy_into<TPM2B_AUTH>(auth_value);
218 check_rc("Esys_TR_SetAuth", Esys_TR_SetAuth(ctx->esys_context(), handle.transient_handle(), &user_auth));
219 }
220
221 return create(std::move(handle), sessions, nullptr /* pull public info from handle */, private_blob);
222}
223
224std::unique_ptr<PrivateKey> PrivateKey::create_transient_from_template(const std::shared_ptr<Context>& ctx,
225 const SessionBundle& sessions,
226 ESYS_TR parent,
227 const TPMT_PUBLIC& key_template,
228 const TPM2B_SENSITIVE_CREATE& sensitive_data) {
230
231 // NOLINTBEGIN(*-branch-clone)
232
233 switch(key_template.type) {
234 case TPM2_ALG_RSA:
235#if not defined(BOTAN_HAS_TPM2_RSA_ADAPTER)
236 throw Not_Implemented("TPM2-based RSA keys are not supported in this build");
237#endif
238 break;
239 case TPM2_ALG_ECC:
240#if not defined(BOTAN_HAS_TPM2_ECC_ADAPTER)
241 throw Not_Implemented("TPM2-based ECC keys are not supported in this build");
242#endif
243 break;
244 default:
245 throw Invalid_Argument("Unsupported key type");
246 }
247
248 // NOLINTEND(*-branch-clone)
249
250 const auto marshalled_template = marshal_template(key_template);
251
252 Object handle(ctx);
253 unique_esys_ptr<TPM2B_PRIVATE> private_bytes;
255
256 // Esys_CreateLoaded can create different object types depending on the type
257 // of the parent passed in. Namely, this will create a Primary object if the
258 // parent is referencing a Primary Seed; an Ordinary Object if the parent is
259 // referencing a Storage Parent; and a Derived Object if the parent is
260 // referencing a Derivation Parent.
261 //
262 // See the Architecture Document, Section 27.1.
263 check_rc("Esys_CreateLoaded",
264 Esys_CreateLoaded(ctx->esys_context(),
265 parent,
266 sessions[0],
267 sessions[1],
268 sessions[2],
269 &sensitive_data,
270 &marshalled_template,
271 out_transient_handle(handle),
272 out_ptr(private_bytes),
273 out_ptr(public_info)));
274 BOTAN_ASSERT_NONNULL(private_bytes);
275 BOTAN_ASSERT_NOMSG(public_info->publicArea.type == key_template.type);
277
278 return create(std::move(handle), sessions, public_info.get(), as_span(*private_bytes));
279}
280
282 BOTAN_STATE_CHECK(!m_handle.has_persistent_handle());
283 BOTAN_ASSERT_NOMSG(!m_private_blob.empty());
284 return Botan::lock(m_private_blob);
285}
286
287std::vector<uint8_t> PrivateKey::raw_public_key_bits() const {
288 return marshal_public_blob(m_handle._public_info(m_sessions).pub.get());
289}
290
292 // Architectural Document, Section 4.54
293 // any object with the decrypt and restricted attributes SET and the sign
294 // attribute CLEAR
295 const auto attrs = m_handle.attributes(m_sessions);
296 return attrs.decrypt && attrs.restricted && !attrs.sign_encrypt;
297}
298
299std::unique_ptr<PrivateKey> PrivateKey::create(Object handles,
300 [[maybe_unused]] const SessionBundle& sessions,
301 [[maybe_unused]] const TPM2B_PUBLIC* public_info,
302 [[maybe_unused]] std::span<const uint8_t> private_blob) {
303 if(public_info == nullptr) {
304 public_info = handles._public_info(sessions).pub.get();
305 }
306
307#if defined(BOTAN_HAS_TPM2_RSA_ADAPTER)
308 if(public_info->publicArea.type == TPM2_ALG_RSA) {
309 return std::unique_ptr<RSA_PrivateKey>(
310 new RSA_PrivateKey(std::move(handles), sessions, public_info, private_blob));
311 }
312#endif
313
314#if defined(BOTAN_HAS_TPM2_ECC_ADAPTER)
315 if(public_info->publicArea.type == TPM2_ALG_ECC) {
316 return std::unique_ptr<EC_PrivateKey>(new EC_PrivateKey(std::move(handles), sessions, public_info, private_blob));
317 }
318#endif
319
320 throw Not_Implemented(Botan::fmt("Loaded a {} private key of an unsupported type",
321 handles.has_persistent_handle() ? "persistent" : "transient"));
322}
323
324} // namespace Botan::TPM2
#define BOTAN_ASSERT_NOMSG(expr)
Definition assert.h:82
#define BOTAN_STATE_CHECK(expr)
Definition assert.h:49
#define BOTAN_ASSERT_NONNULL(ptr)
Definition assert.h:121
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
static std::optional< EC_AffinePoint > deserialize_uncompressed(const EC_Group &group, std::span< const uint8_t > bytes)
static EC_Group from_name(std::string_view name)
Definition ec_group.cpp:529
bool has_transient_handle() const
ESYS_TR transient_handle() const noexcept
static std::unique_ptr< PrivateKey > create_transient_from_template(const std::shared_ptr< Context > &ctx, const SessionBundle &sessions, ESYS_TR parent, const TPMT_PUBLIC &key_template, const TPM2B_SENSITIVE_CREATE &sensitive_data)
Definition tpm2_key.cpp:224
std::vector< uint8_t > raw_public_key_bits() const override
Definition tpm2_key.cpp:287
static std::unique_ptr< PrivateKey > create(Object handles, const SessionBundle &sessions, const TPM2B_PUBLIC *public_info, std::span< const uint8_t > private_blob)
Definition tpm2_key.cpp:299
static std::unique_ptr< PrivateKey > load_persistent(const std::shared_ptr< Context > &ctx, TPM2_HANDLE persistent_object_handle, std::span< const uint8_t > auth_value, const SessionBundle &sessions)
Definition tpm2_key.cpp:184
static std::unique_ptr< PrivateKey > load_transient(const std::shared_ptr< Context > &ctx, std::span< const uint8_t > auth_value, const TPM2::PrivateKey &parent, std::span< const uint8_t > public_blob, std::span< const uint8_t > private_blob, const SessionBundle &sessions)
Definition tpm2_key.cpp:194
const SessionBundle & sessions() const
Definition tpm2_key.h:224
secure_vector< uint8_t > raw_private_key_bits() const override
Definition tpm2_key.cpp:281
static std::unique_ptr< PublicKey > create(Object handles, const SessionBundle &sessions)
Definition tpm2_key.cpp:165
std::vector< uint8_t > raw_public_key_bits() const override
Definition tpm2_key.cpp:161
static std::unique_ptr< PublicKey > load_persistent(const std::shared_ptr< Context > &ctx, TPM2_HANDLE persistent_object_handle, const SessionBundle &sessions={})
Definition tpm2_key.cpp:135
const Object & handles() const
Definition tpm2_key.h:99
const SessionBundle & sessions() const
Definition tpm2_key.h:101
static std::unique_ptr< PublicKey > load_transient(const std::shared_ptr< Context > &ctx, std::span< const uint8_t > public_blob, const SessionBundle &sessions)
Definition tpm2_key.cpp:141
constexpr void check_rc(std::string_view location, TSS2_RC rc)
Definition tpm2_util.h:53
constexpr auto out_persistent_handle(Object &object)
Definition tpm2_util.h:223
std::unique_ptr< T, esys_liberator > unique_esys_ptr
A unique pointer type for ESYS handles that automatically frees the handle.
Definition tpm2_util.h:161
std::optional< std::string > curve_id_tss2_to_botan(TPMI_ECC_CURVE mode_id)
constexpr auto out_transient_handle(Object &object)
Definition tpm2_util.h:217
constexpr void copy_into(T &dest, std::span< const uint8_t > data)
Definition tpm2_util.h:116
constexpr auto as_span(tpm2_buffer auto &data)
Construct a std::span as a view into a TPM2 buffer.
Definition tpm2_util.h:101
constexpr auto out_ptr(T &outptr) noexcept
Definition stl_util.h:164
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
secure_vector< T > lock(const std::vector< T > &in)
Definition secmem.h:145
constexpr auto concat(Rs &&... ranges)
Definition concat_util.h:95
bool value_exists(const std::vector< T > &vec, const V &val)
Definition stl_util.h:44
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
uint32_t ESYS_TR
Forward declaration of TSS2 type for convenience.
uint32_t TPM2_HANDLE
Forward declaration of TSS2 type for convenience.