1 /*
2 * Copyright 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <keymaster/android_keymaster_messages.h>
18 #include <keymaster/android_keymaster_utils.h>
19
20 namespace keymaster {
21
22 namespace {
23
24 /*
25 * Helper functions for working with key blobs.
26 */
27
set_key_blob(keymaster_key_blob_t * key_blob,const void * key_material,size_t length)28 void set_key_blob(keymaster_key_blob_t* key_blob, const void* key_material, size_t length) {
29 delete[] key_blob->key_material;
30 key_blob->key_material = dup_buffer(key_material, length);
31 key_blob->key_material_size = length;
32 }
33
key_blob_size(const keymaster_key_blob_t & key_blob)34 size_t key_blob_size(const keymaster_key_blob_t& key_blob) {
35 return sizeof(uint32_t) /* key size */ + key_blob.key_material_size;
36 }
37
serialize_key_blob(const keymaster_key_blob_t & key_blob,uint8_t * buf,const uint8_t * end)38 uint8_t* serialize_key_blob(const keymaster_key_blob_t& key_blob, uint8_t* buf,
39 const uint8_t* end) {
40 return append_size_and_data_to_buf(buf, end, key_blob.key_material, key_blob.key_material_size);
41 }
42
deserialize_key_blob(keymaster_key_blob_t * key_blob,const uint8_t ** buf_ptr,const uint8_t * end)43 bool deserialize_key_blob(keymaster_key_blob_t* key_blob, const uint8_t** buf_ptr,
44 const uint8_t* end) {
45 delete[] key_blob->key_material;
46 key_blob->key_material = nullptr;
47 UniquePtr<uint8_t[]> deserialized_key_material;
48 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_blob->key_material_size,
49 &deserialized_key_material))
50 return false;
51 key_blob->key_material = deserialized_key_material.release();
52 return true;
53 }
54
set_blob(keymaster_blob_t * blob,const void * data,size_t length)55 void set_blob(keymaster_blob_t* blob, const void* data, size_t length) {
56 assert(blob);
57 assert(data);
58 delete[] blob->data;
59 blob->data = dup_buffer(data, length);
60 blob->data_length = length;
61 }
62
blob_size(const keymaster_blob_t & blob)63 size_t blob_size(const keymaster_blob_t& blob) {
64 return sizeof(uint32_t) /* data size */ + blob.data_length;
65 }
66
serialize_blob(const keymaster_blob_t & blob,uint8_t * buf,const uint8_t * end)67 uint8_t* serialize_blob(const keymaster_blob_t& blob, uint8_t* buf, const uint8_t* end) {
68 return append_size_and_data_to_buf(buf, end, blob.data, blob.data_length);
69 }
70
deserialize_blob(keymaster_blob_t * blob,const uint8_t ** buf_ptr,const uint8_t * end)71 bool deserialize_blob(keymaster_blob_t* blob, const uint8_t** buf_ptr, const uint8_t* end) {
72 delete[] blob->data;
73 *blob = {};
74 UniquePtr<uint8_t[]> deserialized_blob;
75 if (!copy_size_and_data_from_buf(buf_ptr, end, &blob->data_length, &deserialized_blob))
76 return false;
77 blob->data = deserialized_blob.release();
78 return true;
79 }
80
81 /*
82 * Helper functions for working with certificate chains.
83 */
84 const size_t kMaxChainEntryCount = 10;
85
chain_size(const keymaster_cert_chain_t & certificate_chain)86 size_t chain_size(const keymaster_cert_chain_t& certificate_chain) {
87 size_t result = sizeof(uint32_t); /* certificate_chain.entry_count */
88 for (size_t i = 0; i < certificate_chain.entry_count; ++i) {
89 result += sizeof(uint32_t); /* certificate_chain.entries[i].data_length */
90 result += certificate_chain.entries[i].data_length;
91 }
92 return result;
93 }
94
serialize_chain(const keymaster_cert_chain_t & certificate_chain,uint8_t * buf,const uint8_t * end)95 uint8_t* serialize_chain(const keymaster_cert_chain_t& certificate_chain, uint8_t* buf,
96 const uint8_t* end) {
97 buf = append_uint32_to_buf(buf, end, certificate_chain.entry_count);
98 for (size_t i = 0; i < certificate_chain.entry_count; ++i) {
99 buf = append_size_and_data_to_buf(buf, end, certificate_chain.entries[i].data,
100 certificate_chain.entries[i].data_length);
101 }
102 return buf;
103 }
104
deserialize_chain(const uint8_t ** buf_ptr,const uint8_t * end)105 CertificateChain deserialize_chain(const uint8_t** buf_ptr, const uint8_t* end) {
106 size_t entry_count;
107 if (!copy_uint32_from_buf(buf_ptr, end, &entry_count) || entry_count > kMaxChainEntryCount) {
108 return {};
109 }
110
111 CertificateChain certificate_chain(entry_count);
112 if (!certificate_chain.entries) return {};
113
114 for (size_t i = 0; i < certificate_chain.entry_count; ++i) {
115 UniquePtr<uint8_t[]> data;
116 size_t data_length;
117 if (!copy_size_and_data_from_buf(buf_ptr, end, &data_length, &data)) return {};
118 certificate_chain.entries[i].data = data.release();
119 certificate_chain.entries[i].data_length = data_length;
120 }
121
122 return certificate_chain;
123 }
124
125 } // namespace
126
NegotiateMessageVersion(const GetVersionResponse & response,keymaster_error_t * error)127 int32_t NegotiateMessageVersion(const GetVersionResponse& response, keymaster_error_t* error) {
128 switch (response.major_ver) {
129 case 1: // KM1
130 switch (response.minor_ver) {
131 case 0:
132 return MessageVersion(KmVersion::KEYMASTER_1, 0 /* km_date */);
133 case 1:
134 return MessageVersion(KmVersion::KEYMASTER_1_1, 0 /* km_date */);
135 }
136 break;
137 case 2:
138 return MessageVersion(KmVersion::KEYMASTER_2, 0 /* km_date */);
139 case 3:
140 return MessageVersion(KmVersion::KEYMASTER_3, 0 /* km_date */);
141 case 4:
142 switch (response.minor_ver) {
143 case 0:
144 return MessageVersion(KmVersion::KEYMASTER_4, 0 /* km_date */);
145 case 1:
146 return MessageVersion(KmVersion::KEYMASTER_4_1, 0 /* km_date */);
147 }
148 break;
149 }
150
151 *error = KM_ERROR_UNKNOWN_ERROR;
152 return -1;
153 }
154
NegotiateMessageVersion(const GetVersion2Request & request,const GetVersion2Response & response)155 int32_t NegotiateMessageVersion(const GetVersion2Request& request,
156 const GetVersion2Response& response) {
157 return request.max_message_version < response.max_message_version
158 ? request.max_message_version
159 : response.max_message_version;
160 }
161
SerializedSize() const162 size_t KeymasterResponse::SerializedSize() const {
163 if (error != KM_ERROR_OK)
164 return sizeof(int32_t);
165 else
166 return sizeof(int32_t) + NonErrorSerializedSize();
167 }
168
Serialize(uint8_t * buf,const uint8_t * end) const169 uint8_t* KeymasterResponse::Serialize(uint8_t* buf, const uint8_t* end) const {
170 buf = append_uint32_to_buf(buf, end, static_cast<uint32_t>(error));
171 if (error == KM_ERROR_OK) buf = NonErrorSerialize(buf, end);
172 return buf;
173 }
174
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)175 bool KeymasterResponse::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
176 if (!copy_uint32_from_buf(buf_ptr, end, &error)) return false;
177 if (error != KM_ERROR_OK) return true;
178 return NonErrorDeserialize(buf_ptr, end);
179 }
180
SerializedSize() const181 size_t GenerateKeyRequest::SerializedSize() const {
182 size_t size = key_description.SerializedSize();
183 if (message_version < 4) return size;
184 return size //
185 + key_blob_size(attestation_signing_key_blob) //
186 + attest_key_params.SerializedSize() //
187 + blob_size(issuer_subject);
188 }
189
Serialize(uint8_t * buf,const uint8_t * end) const190 uint8_t* GenerateKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
191 buf = key_description.Serialize(buf, end);
192 if (message_version < 4) return buf;
193 buf = serialize_key_blob(attestation_signing_key_blob, buf, end);
194 buf = attest_key_params.Serialize(buf, end);
195 return serialize_blob(issuer_subject, buf, end);
196 }
197
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)198 bool GenerateKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
199 if (!key_description.Deserialize(buf_ptr, end)) return false;
200 if (message_version < 4) return true;
201 return deserialize_key_blob(&attestation_signing_key_blob, buf_ptr, end) //
202 && attest_key_params.Deserialize(buf_ptr, end) //
203 && deserialize_blob(&issuer_subject, buf_ptr, end);
204 }
205
NonErrorSerializedSize() const206 size_t GenerateKeyResponse::NonErrorSerializedSize() const {
207 size_t result =
208 key_blob_size(key_blob) + enforced.SerializedSize() + unenforced.SerializedSize();
209 if (message_version < 4) return result;
210 return result + chain_size(certificate_chain);
211 }
212
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const213 uint8_t* GenerateKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
214 buf = serialize_key_blob(key_blob, buf, end);
215 buf = enforced.Serialize(buf, end);
216 buf = unenforced.Serialize(buf, end);
217 if (message_version < 4) return buf;
218 return serialize_chain(certificate_chain, buf, end);
219 }
220
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)221 bool GenerateKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
222 if (!deserialize_key_blob(&key_blob, buf_ptr, end) || //
223 !enforced.Deserialize(buf_ptr, end) || //
224 !unenforced.Deserialize(buf_ptr, end)) {
225 return false;
226 }
227 if (message_version < 4) return true;
228 certificate_chain = deserialize_chain(buf_ptr, end);
229 return !!certificate_chain.entries;
230 }
231
NonErrorSerializedSize() const232 size_t GenerateRkpKeyResponse::NonErrorSerializedSize() const {
233 return key_blob_size(key_blob) + blob_size(maced_public_key);
234 }
235
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const236 uint8_t* GenerateRkpKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
237 buf = serialize_key_blob(key_blob, buf, end);
238 return serialize_blob(maced_public_key, buf, end);
239 }
240
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)241 bool GenerateRkpKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
242 return deserialize_key_blob(&key_blob, buf_ptr, end) &&
243 deserialize_blob(&maced_public_key, buf_ptr, end);
244 }
245
SerializedSize() const246 size_t GenerateCsrRequest::SerializedSize() const {
247 size_t size = sizeof(uint8_t); /* test_mode */
248 size += sizeof(uint32_t); /* num_keys */
249 for (size_t i = 0; i < num_keys; i++) {
250 size += blob_size(keys_to_sign_array[i]);
251 }
252 size += blob_size(endpoint_enc_cert_chain);
253 size += blob_size(challenge);
254 return size;
255 }
256
Serialize(uint8_t * buf,const uint8_t * end) const257 uint8_t* GenerateCsrRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
258 buf = append_to_buf(buf, end, &test_mode, sizeof(uint8_t));
259 buf = append_uint32_to_buf(buf, end, num_keys);
260 for (size_t i = 0; i < num_keys; i++) {
261 buf = serialize_blob(keys_to_sign_array[i], buf, end);
262 }
263 buf = serialize_blob(endpoint_enc_cert_chain, buf, end);
264 return serialize_blob(challenge, buf, end);
265 }
266
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)267 bool GenerateCsrRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
268 if (!copy_from_buf(buf_ptr, end, &test_mode, sizeof(uint8_t)) ||
269 !copy_from_buf(buf_ptr, end, &num_keys, sizeof(uint32_t))) {
270 return false;
271 }
272 keys_to_sign_array = new (std::nothrow) KeymasterBlob[num_keys];
273 if (!keys_to_sign_array) return false;
274 for (size_t i = 0; i < num_keys; i++) {
275 if (!deserialize_blob(&keys_to_sign_array[i], buf_ptr, end)) return false;
276 }
277 return deserialize_blob(&endpoint_enc_cert_chain, buf_ptr, end) &&
278 deserialize_blob(&challenge, buf_ptr, end);
279 }
280
SetKeyToSign(uint32_t index,const void * data,size_t length)281 void GenerateCsrRequest::SetKeyToSign(uint32_t index, const void* data, size_t length) {
282 if (index >= num_keys) {
283 return;
284 }
285 set_blob(&keys_to_sign_array[index], data, length);
286 }
287
SetEndpointEncCertChain(const void * data,size_t length)288 void GenerateCsrRequest::SetEndpointEncCertChain(const void* data, size_t length) {
289 set_blob(&endpoint_enc_cert_chain, data, length);
290 }
291
SetChallenge(const void * data,size_t length)292 void GenerateCsrRequest::SetChallenge(const void* data, size_t length) {
293 set_blob(&challenge, data, length);
294 }
295
NonErrorSerializedSize() const296 size_t GenerateCsrResponse::NonErrorSerializedSize() const {
297 return blob_size(keys_to_sign_mac) + blob_size(device_info_blob) +
298 blob_size(protected_data_blob);
299 }
300
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const301 uint8_t* GenerateCsrResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
302 buf = serialize_blob(keys_to_sign_mac, buf, end);
303 buf = serialize_blob(device_info_blob, buf, end);
304 return serialize_blob(protected_data_blob, buf, end);
305 }
306
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)307 bool GenerateCsrResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
308 return deserialize_blob(&keys_to_sign_mac, buf_ptr, end) &&
309 deserialize_blob(&device_info_blob, buf_ptr, end) &&
310 deserialize_blob(&protected_data_blob, buf_ptr, end);
311 }
312
SerializedSize() const313 size_t GenerateCsrV2Request::SerializedSize() const {
314 size_t size = sizeof(uint32_t); /* num_keys */
315 for (size_t i = 0; i < num_keys; i++) {
316 size += blob_size(keys_to_sign_array[i]);
317 }
318 size += blob_size(challenge);
319 return size;
320 }
321
Serialize(uint8_t * buf,const uint8_t * end) const322 uint8_t* GenerateCsrV2Request::Serialize(uint8_t* buf, const uint8_t* end) const {
323 buf = append_uint32_to_buf(buf, end, num_keys);
324 for (size_t i = 0; i < num_keys; i++) {
325 buf = serialize_blob(keys_to_sign_array[i], buf, end);
326 }
327 return serialize_blob(challenge, buf, end);
328 }
329
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)330 bool GenerateCsrV2Request::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
331 if (!copy_from_buf(buf_ptr, end, &num_keys, sizeof(uint32_t))) return false;
332
333 keys_to_sign_array = new (std::nothrow) KeymasterBlob[num_keys];
334 if (!keys_to_sign_array) return false;
335 for (size_t i = 0; i < num_keys; i++) {
336 if (!deserialize_blob(&keys_to_sign_array[i], buf_ptr, end)) return false;
337 }
338 return deserialize_blob(&challenge, buf_ptr, end);
339 }
340
InitKeysToSign(uint32_t count)341 bool GenerateCsrV2Request::InitKeysToSign(uint32_t count) {
342 num_keys = count;
343 keys_to_sign_array = new (std::nothrow) KeymasterBlob[count];
344 if (!keys_to_sign_array) {
345 return false;
346 }
347 return true;
348 }
349
SetKeyToSign(uint32_t index,const void * data,size_t length)350 void GenerateCsrV2Request::SetKeyToSign(uint32_t index, const void* data, size_t length) {
351 if (index >= num_keys) {
352 return;
353 }
354 set_blob(&keys_to_sign_array[index], data, length);
355 }
356
SetChallenge(const void * data,size_t length)357 void GenerateCsrV2Request::SetChallenge(const void* data, size_t length) {
358 set_blob(&challenge, data, length);
359 }
360
NonErrorSerializedSize() const361 size_t GenerateCsrV2Response::NonErrorSerializedSize() const {
362 return blob_size(csr);
363 }
364
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const365 uint8_t* GenerateCsrV2Response::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
366 return serialize_blob(csr, buf, end);
367 }
368
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)369 bool GenerateCsrV2Response::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
370 return deserialize_blob(&csr, buf_ptr, end);
371 }
372
~GetKeyCharacteristicsRequest()373 GetKeyCharacteristicsRequest::~GetKeyCharacteristicsRequest() {
374 delete[] key_blob.key_material;
375 }
376
SetKeyMaterial(const void * key_material,size_t length)377 void GetKeyCharacteristicsRequest::SetKeyMaterial(const void* key_material, size_t length) {
378 set_key_blob(&key_blob, key_material, length);
379 }
380
SerializedSize() const381 size_t GetKeyCharacteristicsRequest::SerializedSize() const {
382 return key_blob_size(key_blob) + additional_params.SerializedSize();
383 }
384
Serialize(uint8_t * buf,const uint8_t * end) const385 uint8_t* GetKeyCharacteristicsRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
386 buf = serialize_key_blob(key_blob, buf, end);
387 return additional_params.Serialize(buf, end);
388 }
389
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)390 bool GetKeyCharacteristicsRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
391 return deserialize_key_blob(&key_blob, buf_ptr, end) &&
392 additional_params.Deserialize(buf_ptr, end);
393 }
394
NonErrorSerializedSize() const395 size_t GetKeyCharacteristicsResponse::NonErrorSerializedSize() const {
396 return enforced.SerializedSize() + unenforced.SerializedSize();
397 }
398
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const399 uint8_t* GetKeyCharacteristicsResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
400 buf = enforced.Serialize(buf, end);
401 return unenforced.Serialize(buf, end);
402 }
403
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)404 bool GetKeyCharacteristicsResponse::NonErrorDeserialize(const uint8_t** buf_ptr,
405 const uint8_t* end) {
406 return enforced.Deserialize(buf_ptr, end) && unenforced.Deserialize(buf_ptr, end);
407 }
408
SetKeyMaterial(const void * key_material,size_t length)409 void BeginOperationRequest::SetKeyMaterial(const void* key_material, size_t length) {
410 set_key_blob(&key_blob, key_material, length);
411 }
412
SerializedSize() const413 size_t BeginOperationRequest::SerializedSize() const {
414 return sizeof(uint32_t) /* purpose */ + key_blob_size(key_blob) +
415 additional_params.SerializedSize();
416 }
417
Serialize(uint8_t * buf,const uint8_t * end) const418 uint8_t* BeginOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
419 buf = append_uint32_to_buf(buf, end, purpose);
420 buf = serialize_key_blob(key_blob, buf, end);
421 return additional_params.Serialize(buf, end);
422 }
423
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)424 bool BeginOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
425 return copy_uint32_from_buf(buf_ptr, end, &purpose) &&
426 deserialize_key_blob(&key_blob, buf_ptr, end) &&
427 additional_params.Deserialize(buf_ptr, end);
428 }
429
NonErrorSerializedSize() const430 size_t BeginOperationResponse::NonErrorSerializedSize() const {
431 if (message_version == 0)
432 return sizeof(op_handle);
433 else
434 return sizeof(op_handle) + output_params.SerializedSize();
435 }
436
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const437 uint8_t* BeginOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
438 buf = append_uint64_to_buf(buf, end, op_handle);
439 if (message_version > 0) buf = output_params.Serialize(buf, end);
440 return buf;
441 }
442
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)443 bool BeginOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
444 bool retval = copy_uint64_from_buf(buf_ptr, end, &op_handle);
445 if (retval && message_version > 0) retval = output_params.Deserialize(buf_ptr, end);
446 return retval;
447 }
448
SerializedSize() const449 size_t UpdateOperationRequest::SerializedSize() const {
450 if (message_version == 0)
451 return sizeof(op_handle) + input.SerializedSize();
452 else
453 return sizeof(op_handle) + input.SerializedSize() + additional_params.SerializedSize();
454 }
455
Serialize(uint8_t * buf,const uint8_t * end) const456 uint8_t* UpdateOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
457 buf = append_uint64_to_buf(buf, end, op_handle);
458 buf = input.Serialize(buf, end);
459 if (message_version > 0) buf = additional_params.Serialize(buf, end);
460 return buf;
461 }
462
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)463 bool UpdateOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
464 bool retval = copy_uint64_from_buf(buf_ptr, end, &op_handle) && input.Deserialize(buf_ptr, end);
465 if (retval && message_version > 0) retval = additional_params.Deserialize(buf_ptr, end);
466 return retval;
467 }
468
NonErrorSerializedSize() const469 size_t UpdateOperationResponse::NonErrorSerializedSize() const {
470 size_t size = 0;
471 switch (message_version) {
472 case 4:
473 case 3:
474 case 2:
475 size += output_params.SerializedSize();
476 FALLTHROUGH;
477 case 1:
478 size += sizeof(uint32_t);
479 FALLTHROUGH;
480 case 0:
481 size += output.SerializedSize();
482 break;
483
484 default:
485 assert(false);
486 }
487
488 return size;
489 }
490
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const491 uint8_t* UpdateOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
492 buf = output.Serialize(buf, end);
493 if (message_version > 0) buf = append_uint32_to_buf(buf, end, input_consumed);
494 if (message_version > 1) buf = output_params.Serialize(buf, end);
495 return buf;
496 }
497
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)498 bool UpdateOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
499 bool retval = output.Deserialize(buf_ptr, end);
500 if (retval && message_version > 0) retval = copy_uint32_from_buf(buf_ptr, end, &input_consumed);
501 if (retval && message_version > 1) retval = output_params.Deserialize(buf_ptr, end);
502 return retval;
503 }
504
SerializedSize() const505 size_t FinishOperationRequest::SerializedSize() const {
506 size_t size = 0;
507 switch (message_version) {
508 case 4:
509 case 3:
510 size += input.SerializedSize();
511 FALLTHROUGH;
512 case 2:
513 case 1:
514 size += additional_params.SerializedSize();
515 FALLTHROUGH;
516 case 0:
517 size += sizeof(op_handle) + signature.SerializedSize();
518 break;
519
520 default:
521 assert(false); // Should never get here.
522 }
523
524 return size;
525 }
526
Serialize(uint8_t * buf,const uint8_t * end) const527 uint8_t* FinishOperationRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
528 buf = append_uint64_to_buf(buf, end, op_handle);
529 buf = signature.Serialize(buf, end);
530 if (message_version > 0) buf = additional_params.Serialize(buf, end);
531 if (message_version > 2) buf = input.Serialize(buf, end);
532 return buf;
533 }
534
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)535 bool FinishOperationRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
536 bool retval =
537 copy_uint64_from_buf(buf_ptr, end, &op_handle) && signature.Deserialize(buf_ptr, end);
538 if (retval && message_version > 0) retval = additional_params.Deserialize(buf_ptr, end);
539 if (retval && message_version > 2) retval = input.Deserialize(buf_ptr, end);
540 return retval;
541 }
542
NonErrorSerializedSize() const543 size_t FinishOperationResponse::NonErrorSerializedSize() const {
544 if (message_version < 2)
545 return output.SerializedSize();
546 else
547 return output.SerializedSize() + output_params.SerializedSize();
548 }
549
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const550 uint8_t* FinishOperationResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
551 buf = output.Serialize(buf, end);
552 if (message_version > 1) buf = output_params.Serialize(buf, end);
553 return buf;
554 }
555
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)556 bool FinishOperationResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
557 bool retval = output.Deserialize(buf_ptr, end);
558 if (retval && message_version > 1) retval = output_params.Deserialize(buf_ptr, end);
559 return retval;
560 }
561
SerializedSize() const562 size_t AddEntropyRequest::SerializedSize() const {
563 return random_data.SerializedSize();
564 }
565
Serialize(uint8_t * buf,const uint8_t * end) const566 uint8_t* AddEntropyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
567 return random_data.Serialize(buf, end);
568 }
569
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)570 bool AddEntropyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
571 return random_data.Deserialize(buf_ptr, end);
572 }
573
SerializedSize() const574 size_t ImportKeyRequest::SerializedSize() const {
575 size_t size = key_description.SerializedSize() //
576 + sizeof(uint32_t) /* key_format */ //
577 + key_blob_size(key_data);
578 if (message_version < 4) return size;
579 return size //
580 + key_blob_size(attestation_signing_key_blob) //
581 + attest_key_params.SerializedSize() //
582 + blob_size(issuer_subject);
583 }
584
Serialize(uint8_t * buf,const uint8_t * end) const585 uint8_t* ImportKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
586 buf = key_description.Serialize(buf, end);
587 buf = append_uint32_to_buf(buf, end, key_format);
588 buf = serialize_key_blob(key_data, buf, end);
589 if (message_version < 4) return buf;
590 buf = serialize_key_blob(attestation_signing_key_blob, buf, end);
591 buf = attest_key_params.Serialize(buf, end);
592 return serialize_blob(issuer_subject, buf, end);
593 }
594
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)595 bool ImportKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
596 if (!(key_description.Deserialize(buf_ptr, end) &&
597 copy_uint32_from_buf(buf_ptr, end, &key_format) &&
598 deserialize_key_blob(&key_data, buf_ptr, end))) {
599 return false;
600 }
601 if (message_version < 4) return true;
602
603 return deserialize_key_blob(&attestation_signing_key_blob, buf_ptr, end) //
604 && attest_key_params.Deserialize(buf_ptr, end) //
605 && deserialize_blob(&issuer_subject, buf_ptr, end);
606 }
607
SetKeyMaterial(const void * key_material,size_t length)608 void ImportKeyResponse::SetKeyMaterial(const void* key_material, size_t length) {
609 set_key_blob(&key_blob, key_material, length);
610 }
611
NonErrorSerializedSize() const612 size_t ImportKeyResponse::NonErrorSerializedSize() const {
613 size_t result =
614 key_blob_size(key_blob) + enforced.SerializedSize() + unenforced.SerializedSize();
615 if (message_version < 4) return result;
616 return result + chain_size(certificate_chain);
617 }
618
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const619 uint8_t* ImportKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
620 buf = serialize_key_blob(key_blob, buf, end);
621 buf = enforced.Serialize(buf, end);
622 buf = unenforced.Serialize(buf, end);
623 if (message_version < 4) return buf;
624 return serialize_chain(certificate_chain, buf, end);
625 }
626
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)627 bool ImportKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
628 if (!deserialize_key_blob(&key_blob, buf_ptr, end) || //
629 !enforced.Deserialize(buf_ptr, end) || //
630 !unenforced.Deserialize(buf_ptr, end)) {
631 return false;
632 }
633 if (message_version < 4) return true;
634 certificate_chain = deserialize_chain(buf_ptr, end);
635 return !!certificate_chain.entries;
636 }
637
SetKeyMaterial(const void * key_material,size_t length)638 void ExportKeyRequest::SetKeyMaterial(const void* key_material, size_t length) {
639 set_key_blob(&key_blob, key_material, length);
640 }
641
SerializedSize() const642 size_t ExportKeyRequest::SerializedSize() const {
643 return additional_params.SerializedSize() + sizeof(uint32_t) /* key_format */ +
644 key_blob_size(key_blob);
645 }
646
Serialize(uint8_t * buf,const uint8_t * end) const647 uint8_t* ExportKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
648 buf = additional_params.Serialize(buf, end);
649 buf = append_uint32_to_buf(buf, end, key_format);
650 return serialize_key_blob(key_blob, buf, end);
651 }
652
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)653 bool ExportKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
654 return additional_params.Deserialize(buf_ptr, end) &&
655 copy_uint32_from_buf(buf_ptr, end, &key_format) &&
656 deserialize_key_blob(&key_blob, buf_ptr, end);
657 }
658
SetKeyMaterial(const void * key_material,size_t length)659 void ExportKeyResponse::SetKeyMaterial(const void* key_material, size_t length) {
660 delete[] key_data;
661 key_data = dup_buffer(key_material, length);
662 key_data_length = length;
663 }
664
NonErrorSerializedSize() const665 size_t ExportKeyResponse::NonErrorSerializedSize() const {
666 return sizeof(uint32_t) /* key_data_length */ + key_data_length;
667 }
668
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const669 uint8_t* ExportKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
670 return append_size_and_data_to_buf(buf, end, key_data, key_data_length);
671 }
672
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)673 bool ExportKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
674 delete[] key_data;
675 key_data = nullptr;
676 UniquePtr<uint8_t[]> deserialized_key_material;
677 if (!copy_size_and_data_from_buf(buf_ptr, end, &key_data_length, &deserialized_key_material))
678 return false;
679 key_data = deserialized_key_material.release();
680 return true;
681 }
682
SetKeyMaterial(const void * key_material,size_t length)683 void DeleteKeyRequest::SetKeyMaterial(const void* key_material, size_t length) {
684 set_key_blob(&key_blob, key_material, length);
685 }
686
SerializedSize() const687 size_t DeleteKeyRequest::SerializedSize() const {
688 return key_blob_size(key_blob);
689 }
690
Serialize(uint8_t * buf,const uint8_t * end) const691 uint8_t* DeleteKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
692 return serialize_key_blob(key_blob, buf, end);
693 }
694
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)695 bool DeleteKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
696 return deserialize_key_blob(&key_blob, buf_ptr, end);
697 }
698
NonErrorSerializedSize() const699 size_t GetVersionResponse::NonErrorSerializedSize() const {
700 return sizeof(major_ver) + sizeof(minor_ver) + sizeof(subminor_ver);
701 }
702
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const703 uint8_t* GetVersionResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
704 if (buf + NonErrorSerializedSize() <= end) {
705 *buf++ = major_ver;
706 *buf++ = minor_ver;
707 *buf++ = subminor_ver;
708 } else {
709 buf += NonErrorSerializedSize();
710 }
711 return buf;
712 }
713
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)714 bool GetVersionResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
715 if (*buf_ptr + NonErrorSerializedSize() > end) return false;
716 const uint8_t* tmp = *buf_ptr;
717 major_ver = *tmp++;
718 minor_ver = *tmp++;
719 subminor_ver = *tmp++;
720 *buf_ptr = tmp;
721 return true;
722 }
723
~AttestKeyRequest()724 AttestKeyRequest::~AttestKeyRequest() {
725 delete[] key_blob.key_material;
726 }
727
SetKeyMaterial(const void * key_material,size_t length)728 void AttestKeyRequest::SetKeyMaterial(const void* key_material, size_t length) {
729 set_key_blob(&key_blob, key_material, length);
730 }
731
SerializedSize() const732 size_t AttestKeyRequest::SerializedSize() const {
733 return key_blob_size(key_blob) + attest_params.SerializedSize();
734 }
735
Serialize(uint8_t * buf,const uint8_t * end) const736 uint8_t* AttestKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
737 buf = serialize_key_blob(key_blob, buf, end);
738 return attest_params.Serialize(buf, end);
739 }
740
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)741 bool AttestKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
742 return deserialize_key_blob(&key_blob, buf_ptr, end) && attest_params.Deserialize(buf_ptr, end);
743 }
744
NonErrorSerializedSize() const745 size_t AttestKeyResponse::NonErrorSerializedSize() const {
746 return chain_size(certificate_chain);
747 }
748
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const749 uint8_t* AttestKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
750 return serialize_chain(certificate_chain, buf, end);
751 }
752
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)753 bool AttestKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
754 certificate_chain = deserialize_chain(buf_ptr, end);
755 return !!certificate_chain.entries;
756 }
757
~UpgradeKeyRequest()758 UpgradeKeyRequest::~UpgradeKeyRequest() {
759 delete[] key_blob.key_material;
760 }
761
SetKeyMaterial(const void * key_material,size_t length)762 void UpgradeKeyRequest::SetKeyMaterial(const void* key_material, size_t length) {
763 set_key_blob(&key_blob, key_material, length);
764 }
765
SerializedSize() const766 size_t UpgradeKeyRequest::SerializedSize() const {
767 return key_blob_size(key_blob) + upgrade_params.SerializedSize();
768 }
769
Serialize(uint8_t * buf,const uint8_t * end) const770 uint8_t* UpgradeKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
771 buf = serialize_key_blob(key_blob, buf, end);
772 return upgrade_params.Serialize(buf, end);
773 }
774
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)775 bool UpgradeKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
776 return deserialize_key_blob(&key_blob, buf_ptr, end) &&
777 upgrade_params.Deserialize(buf_ptr, end);
778 }
779
~UpgradeKeyResponse()780 UpgradeKeyResponse::~UpgradeKeyResponse() {
781 delete[] upgraded_key.key_material;
782 }
783
NonErrorSerializedSize() const784 size_t UpgradeKeyResponse::NonErrorSerializedSize() const {
785 return key_blob_size(upgraded_key);
786 }
787
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const788 uint8_t* UpgradeKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
789 return serialize_key_blob(upgraded_key, buf, end);
790 }
791
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)792 bool UpgradeKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
793 return deserialize_key_blob(&upgraded_key, buf_ptr, end);
794 }
795
SerializedSize() const796 size_t HmacSharingParameters::SerializedSize() const {
797 return blob_size(seed) + sizeof(nonce);
798 }
799
Serialize(uint8_t * buf,const uint8_t * end) const800 uint8_t* HmacSharingParameters::Serialize(uint8_t* buf, const uint8_t* end) const {
801 buf = serialize_blob(seed, buf, end);
802 return append_to_buf(buf, end, nonce, sizeof(nonce));
803 }
804
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)805 bool HmacSharingParameters::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
806 return deserialize_blob(&seed, buf_ptr, end) &&
807 copy_from_buf(buf_ptr, end, nonce, sizeof(nonce));
808 }
809
SerializedSize() const810 size_t HmacSharingParametersArray::SerializedSize() const {
811 size_t size = sizeof(uint32_t); // num_params size
812 for (size_t i = 0; i < num_params; ++i) {
813 size += params_array[i].SerializedSize();
814 }
815 return size;
816 }
817
Serialize(uint8_t * buf,const uint8_t * end) const818 uint8_t* HmacSharingParametersArray::Serialize(uint8_t* buf, const uint8_t* end) const {
819 buf = append_uint32_to_buf(buf, end, num_params);
820 for (size_t i = 0; i < num_params; ++i) {
821 buf = params_array[i].Serialize(buf, end);
822 }
823 return buf;
824 }
825
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)826 bool HmacSharingParametersArray::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
827 if (!copy_uint32_from_buf(buf_ptr, end, &num_params)) return false;
828 params_array = new (std::nothrow) HmacSharingParameters[num_params];
829 if (!params_array) return false;
830 for (size_t i = 0; i < num_params; ++i) {
831 if (!params_array[i].Deserialize(buf_ptr, end)) return false;
832 }
833 return true;
834 }
835
NonErrorSerializedSize() const836 size_t ComputeSharedHmacResponse::NonErrorSerializedSize() const {
837 return blob_size(sharing_check);
838 }
839
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const840 uint8_t* ComputeSharedHmacResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
841 return serialize_blob(sharing_check, buf, end);
842 }
843
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)844 bool ComputeSharedHmacResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
845 return deserialize_blob(&sharing_check, buf_ptr, end);
846 }
847
SerializedSize() const848 size_t ImportWrappedKeyRequest::SerializedSize() const {
849 return key_blob_size(wrapped_key) + key_blob_size(wrapping_key) + key_blob_size(masking_key) +
850 additional_params.SerializedSize() + sizeof(uint64_t) // password_sid
851 + sizeof(uint64_t); // biometric_sid
852 }
853
Serialize(uint8_t * buf,const uint8_t * end) const854 uint8_t* ImportWrappedKeyRequest::Serialize(uint8_t* buf, const uint8_t* end) const {
855 buf = serialize_key_blob(wrapped_key, buf, end);
856 buf = serialize_key_blob(wrapping_key, buf, end);
857 buf = serialize_key_blob(masking_key, buf, end);
858 buf = additional_params.Serialize(buf, end);
859 buf = append_uint64_to_buf(buf, end, password_sid);
860 return append_uint64_to_buf(buf, end, biometric_sid);
861 }
862
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)863 bool ImportWrappedKeyRequest::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
864 return deserialize_key_blob(&wrapped_key, buf_ptr, end) &&
865 deserialize_key_blob(&wrapping_key, buf_ptr, end) &&
866 deserialize_key_blob(&masking_key, buf_ptr, end) &&
867 additional_params.Deserialize(buf_ptr, end) &&
868 copy_uint64_from_buf(buf_ptr, end, &password_sid) &&
869 copy_uint64_from_buf(buf_ptr, end, &biometric_sid);
870 }
871
SetWrappedMaterial(const void * key_material,size_t length)872 void ImportWrappedKeyRequest::SetWrappedMaterial(const void* key_material, size_t length) {
873 set_key_blob(&wrapped_key, key_material, length);
874 }
875
SetWrappingMaterial(const void * key_material,size_t length)876 void ImportWrappedKeyRequest::SetWrappingMaterial(const void* key_material, size_t length) {
877 set_key_blob(&wrapping_key, key_material, length);
878 }
879
SetMaskingKeyMaterial(const void * key_material,size_t length)880 void ImportWrappedKeyRequest::SetMaskingKeyMaterial(const void* key_material, size_t length) {
881 set_key_blob(&masking_key, key_material, length);
882 }
883
SetKeyMaterial(const void * key_material,size_t length)884 void ImportWrappedKeyResponse::SetKeyMaterial(const void* key_material, size_t length) {
885 set_key_blob(&key_blob, key_material, length);
886 }
887
NonErrorSerializedSize() const888 size_t ImportWrappedKeyResponse::NonErrorSerializedSize() const {
889 size_t result =
890 key_blob_size(key_blob) + enforced.SerializedSize() + unenforced.SerializedSize();
891 if (message_version < 4) return result;
892 return result + chain_size(certificate_chain);
893 }
894
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const895 uint8_t* ImportWrappedKeyResponse::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
896 buf = serialize_key_blob(key_blob, buf, end);
897 buf = enforced.Serialize(buf, end);
898 buf = unenforced.Serialize(buf, end);
899 if (message_version < 4) return buf;
900 return serialize_chain(certificate_chain, buf, end);
901 }
902
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)903 bool ImportWrappedKeyResponse::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
904 if (!deserialize_key_blob(&key_blob, buf_ptr, end) || //
905 !enforced.Deserialize(buf_ptr, end) || //
906 !unenforced.Deserialize(buf_ptr, end)) {
907 return false;
908 }
909 if (message_version < 4) return true;
910 certificate_chain = deserialize_chain(buf_ptr, end);
911 return !!certificate_chain.entries;
912 }
913
SerializedSize() const914 size_t HardwareAuthToken::SerializedSize() const {
915 return sizeof(challenge) + sizeof(user_id) + sizeof(authenticator_id) +
916 sizeof(authenticator_type) + sizeof(timestamp) + blob_size(mac);
917 }
918
Serialize(uint8_t * buf,const uint8_t * end) const919 uint8_t* HardwareAuthToken::Serialize(uint8_t* buf, const uint8_t* end) const {
920 buf = append_uint64_to_buf(buf, end, challenge);
921 buf = append_uint64_to_buf(buf, end, user_id);
922 buf = append_uint64_to_buf(buf, end, authenticator_id);
923 buf = append_uint32_to_buf(buf, end, authenticator_type);
924 buf = append_uint64_to_buf(buf, end, timestamp);
925 return serialize_blob(mac, buf, end);
926 }
927
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)928 bool HardwareAuthToken::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
929 return copy_uint64_from_buf(buf_ptr, end, &challenge) &&
930 copy_uint64_from_buf(buf_ptr, end, &user_id) &&
931 copy_uint64_from_buf(buf_ptr, end, &authenticator_id) &&
932 copy_uint32_from_buf(buf_ptr, end, &authenticator_type) &&
933 copy_uint64_from_buf(buf_ptr, end, ×tamp) && //
934 deserialize_blob(&mac, buf_ptr, end);
935 }
936
SerializedSize() const937 size_t VerificationToken::SerializedSize() const {
938 return sizeof(challenge) + sizeof(timestamp) + parameters_verified.SerializedSize() +
939 sizeof(security_level) + blob_size(mac);
940 }
941
Serialize(uint8_t * buf,const uint8_t * end) const942 uint8_t* VerificationToken::Serialize(uint8_t* buf, const uint8_t* end) const {
943 buf = append_uint64_to_buf(buf, end, challenge);
944 buf = append_uint64_to_buf(buf, end, timestamp);
945 buf = parameters_verified.Serialize(buf, end);
946 buf = append_uint32_to_buf(buf, end, security_level);
947 return serialize_blob(mac, buf, end);
948 }
949
Deserialize(const uint8_t ** buf_ptr,const uint8_t * end)950 bool VerificationToken::Deserialize(const uint8_t** buf_ptr, const uint8_t* end) {
951 return copy_uint64_from_buf(buf_ptr, end, &challenge) &&
952 copy_uint64_from_buf(buf_ptr, end, ×tamp) &&
953 parameters_verified.Deserialize(buf_ptr, end) &&
954 copy_uint32_from_buf(buf_ptr, end, &security_level) &&
955 deserialize_blob(&mac, buf_ptr, end);
956 }
957
NonErrorSerializedSize() const958 size_t GetVersion2Response::NonErrorSerializedSize() const {
959 return sizeof(max_message_version) + //
960 sizeof(km_version) + //
961 sizeof(km_date);
962 }
963
NonErrorSerialize(uint8_t * buf,const uint8_t * end) const964 uint8_t* GetVersion2Response::NonErrorSerialize(uint8_t* buf, const uint8_t* end) const {
965 buf = append_uint32_to_buf(buf, end, max_message_version);
966 buf = append_uint32_to_buf(buf, end, km_version);
967 return append_uint32_to_buf(buf, end, km_date);
968 }
969
NonErrorDeserialize(const uint8_t ** buf_ptr,const uint8_t * end)970 bool GetVersion2Response::NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
971 return copy_uint32_from_buf(buf_ptr, end, &max_message_version) &&
972 copy_uint32_from_buf(buf_ptr, end, &km_version) &&
973 copy_uint32_from_buf(buf_ptr, end, &km_date);
974 }
975
976 } // namespace keymaster
977