1 /*
2 * Copyright (C) 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/UniquePtr.h>
18
19 #include <gtest/gtest.h>
20
21 #include <keymaster/android_keymaster.h>
22 #include <keymaster/android_keymaster_utils.h>
23 #include <keymaster/keymaster_tags.h>
24
25 #include "android_keymaster_test_utils.h"
26
27 namespace keymaster {
28 namespace test {
29
30 /**
31 * Serialize and deserialize a message.
32 */
33 template <typename Message>
round_trip(int32_t ver,const Message & message,size_t expected_size)34 Message* round_trip(int32_t ver, const Message& message, size_t expected_size) {
35 size_t size = message.SerializedSize();
36 EXPECT_EQ(expected_size, size);
37 if (size == 0) return nullptr;
38
39 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
40 EXPECT_EQ(buf.get() + size, message.Serialize(buf.get(), buf.get() + size));
41
42 Message* deserialized = new Message(ver);
43 const uint8_t* p = buf.get();
44 EXPECT_TRUE(deserialized->Deserialize(&p, p + size));
45 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
46 return deserialized;
47 }
48
TEST(RoundTrip,EmptyKeymasterResponse)49 TEST(RoundTrip, EmptyKeymasterResponse) {
50 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
51 EmptyKeymasterResponse msg(ver);
52 msg.error = KM_ERROR_OK;
53
54 UniquePtr<EmptyKeymasterResponse> deserialized(round_trip(ver, msg, 4));
55 }
56 }
57
TEST(RoundTrip,EmptyKeymasterResponseError)58 TEST(RoundTrip, EmptyKeymasterResponseError) {
59 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
60 EmptyKeymasterResponse msg(ver);
61 msg.error = KM_ERROR_MEMORY_ALLOCATION_FAILED;
62
63 UniquePtr<EmptyKeymasterResponse> deserialized(round_trip(ver, msg, 4));
64 }
65 }
66
67 static keymaster_key_param_t params[] = {
68 Authorization(TAG_PURPOSE, KM_PURPOSE_SIGN),
69 Authorization(TAG_PURPOSE, KM_PURPOSE_VERIFY),
70 Authorization(TAG_ALGORITHM, KM_ALGORITHM_RSA),
71 Authorization(TAG_USER_ID, 7),
72 Authorization(TAG_USER_AUTH_TYPE, HW_AUTH_PASSWORD),
73 Authorization(TAG_APPLICATION_ID, "app_id", 6),
74 Authorization(TAG_AUTH_TIMEOUT, 300),
75 };
76 uint8_t TEST_DATA[] = "a key blob";
77
TEST(RoundTrip,GenerateKeyRequest)78 TEST(RoundTrip, GenerateKeyRequest) {
79 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
80 GenerateKeyRequest req(ver);
81 req.key_description.Reinitialize(params, array_length(params));
82 req.attestation_signing_key_blob =
83 KeymasterKeyBlob(reinterpret_cast<const uint8_t*>("foo"), 3);
84 req.attest_key_params.Reinitialize(params, array_length(params));
85 req.issuer_subject = KeymasterBlob(reinterpret_cast<const uint8_t*>("bar"), 3);
86
87 UniquePtr<GenerateKeyRequest> deserialized(round_trip(ver, req, ver < 4 ? 78 : 170));
88 EXPECT_EQ(deserialized->key_description, req.key_description);
89 if (ver < 4) {
90 EXPECT_EQ(0U, deserialized->attestation_signing_key_blob.key_material_size);
91 } else {
92 EXPECT_EQ(3U, deserialized->attestation_signing_key_blob.key_material_size);
93 EXPECT_EQ(0, memcmp(req.attestation_signing_key_blob.key_material,
94 deserialized->attestation_signing_key_blob.key_material,
95 deserialized->attestation_signing_key_blob.key_material_size));
96 EXPECT_EQ(deserialized->attest_key_params, req.attest_key_params);
97 EXPECT_EQ(0, memcmp(req.issuer_subject.data, deserialized->issuer_subject.data,
98 deserialized->issuer_subject.data_length));
99 }
100 }
101 }
102
TEST(RoundTrip,GenerateKeyResponse)103 TEST(RoundTrip, GenerateKeyResponse) {
104 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
105 GenerateKeyResponse rsp(ver);
106 rsp.error = KM_ERROR_OK;
107 rsp.key_blob.key_material = dup_array(TEST_DATA);
108 rsp.key_blob.key_material_size = array_length(TEST_DATA);
109 rsp.enforced.Reinitialize(params, array_length(params));
110
111 rsp.certificate_chain = CertificateChain(3);
112 rsp.certificate_chain.entries[0] = {dup_buffer("foo", 3), 3};
113 rsp.certificate_chain.entries[1] = {dup_buffer("bar", 3), 3};
114 rsp.certificate_chain.entries[2] = {dup_buffer("baz", 3), 3};
115
116 UniquePtr<GenerateKeyResponse> deserialized;
117 if (ver < 4) {
118 deserialized.reset(round_trip(ver, rsp, 109));
119 } else {
120 deserialized.reset(round_trip(ver, rsp, 134));
121 }
122
123 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
124 EXPECT_EQ(deserialized->enforced, rsp.enforced);
125 EXPECT_EQ(deserialized->unenforced, rsp.unenforced);
126
127 keymaster_cert_chain_t* chain = &deserialized->certificate_chain;
128 if (ver < 4) {
129 EXPECT_EQ(nullptr, chain->entries);
130 } else {
131 EXPECT_NE(nullptr, chain->entries);
132 EXPECT_EQ(3U, chain->entry_count);
133 EXPECT_EQ(3U, chain->entries[0].data_length);
134 EXPECT_EQ(0, memcmp("foo", chain->entries[0].data, 3));
135 EXPECT_EQ(3U, chain->entries[1].data_length);
136 EXPECT_EQ(0, memcmp("bar", chain->entries[1].data, 3));
137 EXPECT_EQ(3U, chain->entries[2].data_length);
138 EXPECT_EQ(0, memcmp("baz", chain->entries[2].data, 3));
139 }
140 }
141 }
142
TEST(RoundTrip,GenerateKeyResponseTestError)143 TEST(RoundTrip, GenerateKeyResponseTestError) {
144 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
145 GenerateKeyResponse rsp(ver);
146 rsp.error = KM_ERROR_UNSUPPORTED_ALGORITHM;
147 rsp.key_blob.key_material = dup_array(TEST_DATA);
148 rsp.key_blob.key_material_size = array_length(TEST_DATA);
149 rsp.enforced.Reinitialize(params, array_length(params));
150
151 UniquePtr<GenerateKeyResponse> deserialized(round_trip(ver, rsp, 4));
152 EXPECT_EQ(KM_ERROR_UNSUPPORTED_ALGORITHM, deserialized->error);
153 EXPECT_EQ(0U, deserialized->enforced.size());
154 EXPECT_EQ(0U, deserialized->unenforced.size());
155 EXPECT_EQ(0U, deserialized->key_blob.key_material_size);
156 }
157 }
158
TEST(RoundTrip,GenerateRkpKeyRequest)159 TEST(RoundTrip, GenerateRkpKeyRequest) {
160 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
161 GenerateRkpKeyRequest req(ver);
162 req.test_mode = true;
163
164 UniquePtr<GenerateRkpKeyRequest> deserialized(round_trip(ver, req, 1));
165 EXPECT_EQ(deserialized->test_mode, req.test_mode);
166 }
167 }
168
TEST(RoundTrip,GenerateRkpKeyResponse)169 TEST(RoundTrip, GenerateRkpKeyResponse) {
170 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
171 GenerateRkpKeyResponse rsp(ver);
172 rsp.error = KM_ERROR_OK;
173 rsp.key_blob.key_material = dup_array(TEST_DATA);
174 rsp.key_blob.key_material_size = array_length(TEST_DATA);
175 rsp.maced_public_key.data = dup_array(TEST_DATA);
176 rsp.maced_public_key.data_length = array_length(TEST_DATA);
177
178 UniquePtr<GenerateRkpKeyResponse> deserialized;
179 deserialized.reset(round_trip(ver, rsp, 34));
180
181 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
182 EXPECT_EQ(deserialized->key_blob.key_material_size, rsp.key_blob.key_material_size);
183 EXPECT_EQ(0, std::memcmp(deserialized->key_blob.key_material, rsp.key_blob.key_material,
184 deserialized->key_blob.key_material_size));
185 EXPECT_EQ(deserialized->maced_public_key.data_length, rsp.maced_public_key.data_length);
186 EXPECT_EQ(0, std::memcmp(deserialized->maced_public_key.data, rsp.maced_public_key.data,
187 deserialized->maced_public_key.data_length));
188 }
189 }
190
TEST(RoundTrip,GenerateCsrRequest)191 TEST(RoundTrip, GenerateCsrRequest) {
192 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
193 GenerateCsrRequest req(ver);
194 req.test_mode = true;
195 req.num_keys = 2;
196 req.keys_to_sign_array = new KeymasterBlob[req.num_keys];
197 for (size_t i = 0; i < req.num_keys; i++) {
198 req.SetKeyToSign(i, dup_array(TEST_DATA), array_length(TEST_DATA));
199 }
200 req.SetEndpointEncCertChain(dup_array(TEST_DATA), array_length(TEST_DATA));
201 req.SetChallenge(dup_array(TEST_DATA), array_length(TEST_DATA));
202 UniquePtr<GenerateCsrRequest> deserialized(round_trip(ver, req, 65));
203 EXPECT_EQ(deserialized->test_mode, req.test_mode);
204 EXPECT_EQ(deserialized->num_keys, req.num_keys);
205 for (int i = 0; i < (int)req.num_keys; i++) {
206 EXPECT_EQ(deserialized->keys_to_sign_array[i].data_length,
207 req.keys_to_sign_array[i].data_length);
208 EXPECT_EQ(0, std::memcmp(deserialized->keys_to_sign_array[i].data,
209 req.keys_to_sign_array[i].data,
210 req.keys_to_sign_array[i].data_length));
211 }
212 EXPECT_EQ(deserialized->endpoint_enc_cert_chain.data_length,
213 req.endpoint_enc_cert_chain.data_length);
214 EXPECT_EQ(0, std::memcmp(deserialized->endpoint_enc_cert_chain.data,
215 req.endpoint_enc_cert_chain.data,
216 req.endpoint_enc_cert_chain.data_length));
217 EXPECT_EQ(deserialized->challenge.data_length, req.challenge.data_length);
218 EXPECT_EQ(0, std::memcmp(deserialized->challenge.data, req.challenge.data,
219 req.challenge.data_length));
220 }
221 }
222
TEST(RoundTrip,GenerateCsrResponse)223 TEST(RoundTrip, GenerateCsrResponse) {
224 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
225 GenerateCsrResponse rsp(ver);
226 rsp.error = KM_ERROR_OK;
227 rsp.keys_to_sign_mac.data = dup_array(TEST_DATA);
228 rsp.keys_to_sign_mac.data_length = array_length(TEST_DATA);
229 rsp.device_info_blob.data = dup_array(TEST_DATA);
230 rsp.device_info_blob.data_length = array_length(TEST_DATA);
231 rsp.protected_data_blob.data = dup_array(TEST_DATA);
232 rsp.protected_data_blob.data_length = array_length(TEST_DATA);
233
234 UniquePtr<GenerateCsrResponse> deserialized;
235 deserialized.reset(round_trip(ver, rsp, 49));
236
237 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
238 EXPECT_EQ(deserialized->keys_to_sign_mac.data_length, rsp.keys_to_sign_mac.data_length);
239 EXPECT_EQ(0, std::memcmp(deserialized->keys_to_sign_mac.data, rsp.keys_to_sign_mac.data,
240 deserialized->keys_to_sign_mac.data_length));
241 EXPECT_EQ(deserialized->device_info_blob.data_length, rsp.device_info_blob.data_length);
242 EXPECT_EQ(0, std::memcmp(deserialized->device_info_blob.data, rsp.device_info_blob.data,
243 deserialized->device_info_blob.data_length));
244 EXPECT_EQ(deserialized->protected_data_blob.data_length,
245 rsp.protected_data_blob.data_length);
246 EXPECT_EQ(0,
247 std::memcmp(deserialized->protected_data_blob.data, rsp.protected_data_blob.data,
248 deserialized->protected_data_blob.data_length));
249 }
250 }
251
TEST(RoundTrip,GetKeyCharacteristicsRequest)252 TEST(RoundTrip, GetKeyCharacteristicsRequest) {
253 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
254 GetKeyCharacteristicsRequest req(ver);
255 req.additional_params.Reinitialize(params, array_length(params));
256 req.SetKeyMaterial("foo", 3);
257
258 UniquePtr<GetKeyCharacteristicsRequest> deserialized(round_trip(ver, req, 85));
259 EXPECT_EQ(7U, deserialized->additional_params.size());
260 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
261 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
262 }
263 }
264
TEST(RoundTrip,GetKeyCharacteristicsResponse)265 TEST(RoundTrip, GetKeyCharacteristicsResponse) {
266 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
267 GetKeyCharacteristicsResponse msg(ver);
268 msg.error = KM_ERROR_OK;
269 msg.enforced.Reinitialize(params, array_length(params));
270 msg.unenforced.Reinitialize(params, array_length(params));
271
272 UniquePtr<GetKeyCharacteristicsResponse> deserialized(round_trip(ver, msg, 160));
273 EXPECT_EQ(msg.enforced, deserialized->enforced);
274 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
275 }
276 }
277
TEST(RoundTrip,BeginOperationRequest)278 TEST(RoundTrip, BeginOperationRequest) {
279 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
280 BeginOperationRequest msg(ver);
281 msg.purpose = KM_PURPOSE_SIGN;
282 msg.SetKeyMaterial("foo", 3);
283 msg.additional_params.Reinitialize(params, array_length(params));
284
285 UniquePtr<BeginOperationRequest> deserialized(round_trip(ver, msg, 89));
286 EXPECT_EQ(KM_PURPOSE_SIGN, deserialized->purpose);
287 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
288 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
289 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
290 }
291 }
292
TEST(RoundTrip,BeginOperationResponse)293 TEST(RoundTrip, BeginOperationResponse) {
294 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
295 BeginOperationResponse msg(ver);
296 msg.error = KM_ERROR_OK;
297 msg.op_handle = 0xDEADBEEF;
298 msg.output_params.push_back(Authorization(TAG_NONCE, "foo", 3));
299
300 UniquePtr<BeginOperationResponse> deserialized;
301 switch (ver) {
302 case 0:
303 deserialized.reset(round_trip(ver, msg, 12));
304 break;
305 case 1:
306 case 2:
307 case 3:
308 case 4:
309 deserialized.reset(round_trip(ver, msg, 39));
310 break;
311 default:
312 FAIL();
313 }
314
315 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
316 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
317
318 switch (ver) {
319 case 0:
320 EXPECT_EQ(0U, deserialized->output_params.size());
321 break;
322 case 1:
323 case 2:
324 case 3:
325 case 4:
326 EXPECT_EQ(msg.output_params, deserialized->output_params);
327 break;
328 default:
329 FAIL();
330 }
331 }
332 }
333
TEST(RoundTrip,BeginOperationResponseError)334 TEST(RoundTrip, BeginOperationResponseError) {
335 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
336 BeginOperationResponse msg(ver);
337 msg.error = KM_ERROR_INVALID_OPERATION_HANDLE;
338 msg.op_handle = 0xDEADBEEF;
339
340 UniquePtr<BeginOperationResponse> deserialized(round_trip(ver, msg, 4));
341 EXPECT_EQ(KM_ERROR_INVALID_OPERATION_HANDLE, deserialized->error);
342 }
343 }
344
TEST(RoundTrip,UpdateOperationRequest)345 TEST(RoundTrip, UpdateOperationRequest) {
346 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
347 UpdateOperationRequest msg(ver);
348 msg.op_handle = 0xDEADBEEF;
349 msg.input.Reinitialize("foo", 3);
350
351 UniquePtr<UpdateOperationRequest> deserialized;
352 switch (ver) {
353 case 0:
354 deserialized.reset(round_trip(ver, msg, 15));
355 break;
356 case 1:
357 case 2:
358 case 3:
359 case 4:
360 deserialized.reset(round_trip(ver, msg, 27));
361 break;
362 default:
363 FAIL();
364 }
365 EXPECT_EQ(3U, deserialized->input.available_read());
366 EXPECT_EQ(0, memcmp(deserialized->input.peek_read(), "foo", 3));
367 }
368 }
369
TEST(RoundTrip,UpdateOperationResponse)370 TEST(RoundTrip, UpdateOperationResponse) {
371 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
372 UpdateOperationResponse msg(ver);
373 msg.error = KM_ERROR_OK;
374 msg.output.Reinitialize("foo", 3);
375 msg.input_consumed = 99;
376 msg.output_params.push_back(TAG_APPLICATION_ID, "bar", 3);
377
378 UniquePtr<UpdateOperationResponse> deserialized;
379 switch (ver) {
380 case 0:
381 deserialized.reset(round_trip(ver, msg, 11));
382 break;
383 case 1:
384 deserialized.reset(round_trip(ver, msg, 15));
385 break;
386 case 2:
387 case 3:
388 case 4:
389 deserialized.reset(round_trip(ver, msg, 42));
390 break;
391 default:
392 FAIL();
393 }
394 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
395 EXPECT_EQ(3U, deserialized->output.available_read());
396 EXPECT_EQ(0, memcmp(deserialized->output.peek_read(), "foo", 3));
397
398 switch (ver) {
399 case 0:
400 EXPECT_EQ(0U, deserialized->input_consumed);
401 break;
402 case 1:
403 EXPECT_EQ(99U, deserialized->input_consumed);
404 break;
405 case 2:
406 case 3:
407 case 4:
408 EXPECT_EQ(99U, deserialized->input_consumed);
409 EXPECT_EQ(1U, deserialized->output_params.size());
410 break;
411 default:
412 FAIL();
413 }
414 }
415 }
416
TEST(RoundTrip,FinishOperationRequest)417 TEST(RoundTrip, FinishOperationRequest) {
418 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
419 FinishOperationRequest msg(ver);
420 msg.op_handle = 0xDEADBEEF;
421 msg.signature.Reinitialize("bar", 3);
422 msg.input.Reinitialize("baz", 3);
423
424 UniquePtr<FinishOperationRequest> deserialized;
425 switch (ver) {
426 case 0:
427 deserialized.reset(round_trip(ver, msg, 15));
428 break;
429 case 1:
430 case 2:
431 deserialized.reset(round_trip(ver, msg, 27));
432 break;
433 case 3:
434 case 4:
435 deserialized.reset(round_trip(ver, msg, 34));
436 break;
437 default:
438 FAIL();
439 }
440 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
441 EXPECT_EQ(3U, deserialized->signature.available_read());
442 EXPECT_EQ(0, memcmp(deserialized->signature.peek_read(), "bar", 3));
443 }
444 }
445
TEST(Round_Trip,FinishOperationResponse)446 TEST(Round_Trip, FinishOperationResponse) {
447 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
448 FinishOperationResponse msg(ver);
449 msg.error = KM_ERROR_OK;
450 msg.output.Reinitialize("foo", 3);
451
452 UniquePtr<FinishOperationResponse> deserialized;
453 switch (ver) {
454 case 0:
455 case 1:
456 deserialized.reset(round_trip(ver, msg, 11));
457 break;
458 case 2:
459 case 3:
460 case 4:
461 deserialized.reset(round_trip(ver, msg, 23));
462 break;
463 default:
464 FAIL();
465 }
466 EXPECT_EQ(msg.error, deserialized->error);
467 EXPECT_EQ(msg.output.available_read(), deserialized->output.available_read());
468 EXPECT_EQ(0, memcmp(msg.output.peek_read(), deserialized->output.peek_read(),
469 msg.output.available_read()));
470 }
471 }
472
TEST(RoundTrip,ImportKeyRequest)473 TEST(RoundTrip, ImportKeyRequest) {
474 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
475 ImportKeyRequest msg(ver);
476 msg.key_description.Reinitialize(params, array_length(params));
477 msg.key_format = KM_KEY_FORMAT_X509;
478 msg.key_data = KeymasterKeyBlob(reinterpret_cast<const uint8_t*>("foo"), 3);
479 msg.attestation_signing_key_blob =
480 KeymasterKeyBlob(reinterpret_cast<const uint8_t*>("bar"), 3);
481 msg.attest_key_params.Reinitialize(params, array_length(params));
482 msg.issuer_subject = KeymasterBlob(reinterpret_cast<const uint8_t*>("bar"), 3);
483
484 UniquePtr<ImportKeyRequest> deserialized(round_trip(ver, msg, ver < 4 ? 89 : 181));
485 EXPECT_EQ(msg.key_description, deserialized->key_description);
486 EXPECT_EQ(msg.key_format, deserialized->key_format);
487 EXPECT_EQ(msg.key_data.key_material_size, deserialized->key_data.key_material_size);
488 EXPECT_EQ(0, memcmp(msg.key_data.key_material, deserialized->key_data.key_material,
489 msg.key_data.key_material_size));
490 if (ver < 4) {
491 EXPECT_EQ(0U, deserialized->attestation_signing_key_blob.key_material_size);
492 } else {
493 EXPECT_EQ(3U, deserialized->attestation_signing_key_blob.key_material_size);
494 EXPECT_EQ(0, memcmp(msg.attestation_signing_key_blob.key_material,
495 deserialized->attestation_signing_key_blob.key_material,
496 msg.attestation_signing_key_blob.key_material_size));
497 EXPECT_EQ(deserialized->attest_key_params, msg.attest_key_params);
498 EXPECT_EQ(0, memcmp(msg.issuer_subject.data, deserialized->issuer_subject.data,
499 deserialized->issuer_subject.data_length));
500 }
501 }
502 }
503
TEST(RoundTrip,ImportKeyResponse)504 TEST(RoundTrip, ImportKeyResponse) {
505 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
506 ImportKeyResponse msg(ver);
507 msg.error = KM_ERROR_OK;
508 msg.SetKeyMaterial("foo", 3);
509 msg.enforced.Reinitialize(params, array_length(params));
510 msg.unenforced.Reinitialize(params, array_length(params));
511
512 msg.certificate_chain = CertificateChain(3);
513 msg.certificate_chain.entries[0] = {dup_buffer("foo", 3), 3};
514 msg.certificate_chain.entries[1] = {dup_buffer("bar", 3), 3};
515 msg.certificate_chain.entries[2] = {dup_buffer("baz", 3), 3};
516
517 UniquePtr<ImportKeyResponse> deserialized;
518 if (ver < 4) {
519 deserialized.reset(round_trip(ver, msg, 167));
520 } else {
521 deserialized.reset(round_trip(ver, msg, 192));
522 }
523
524 EXPECT_EQ(msg.error, deserialized->error);
525 EXPECT_EQ(msg.key_blob.key_material_size, deserialized->key_blob.key_material_size);
526 EXPECT_EQ(0, memcmp(msg.key_blob.key_material, deserialized->key_blob.key_material,
527 msg.key_blob.key_material_size));
528 EXPECT_EQ(msg.enforced, deserialized->enforced);
529 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
530
531 keymaster_cert_chain_t* chain = &deserialized->certificate_chain;
532 if (ver < 4) {
533 EXPECT_EQ(nullptr, chain->entries);
534 } else {
535 EXPECT_NE(nullptr, chain->entries);
536 EXPECT_EQ(3U, chain->entry_count);
537 EXPECT_EQ(3U, chain->entries[0].data_length);
538 EXPECT_EQ(0, memcmp("foo", chain->entries[0].data, 3));
539 EXPECT_EQ(3U, chain->entries[1].data_length);
540 EXPECT_EQ(0, memcmp("bar", chain->entries[1].data, 3));
541 EXPECT_EQ(3U, chain->entries[2].data_length);
542 EXPECT_EQ(0, memcmp("baz", chain->entries[2].data, 3));
543 }
544 }
545 }
546
TEST(RoundTrip,ExportKeyRequest)547 TEST(RoundTrip, ExportKeyRequest) {
548 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
549 ExportKeyRequest msg(ver);
550 msg.additional_params.Reinitialize(params, array_length(params));
551 msg.key_format = KM_KEY_FORMAT_X509;
552 msg.SetKeyMaterial("foo", 3);
553
554 UniquePtr<ExportKeyRequest> deserialized(round_trip(ver, msg, 89));
555 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
556 EXPECT_EQ(msg.key_format, deserialized->key_format);
557 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
558 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
559 }
560 }
561
TEST(RoundTrip,ExportKeyResponse)562 TEST(RoundTrip, ExportKeyResponse) {
563 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
564 ExportKeyResponse msg(ver);
565 msg.error = KM_ERROR_OK;
566 msg.SetKeyMaterial("foo", 3);
567
568 UniquePtr<ExportKeyResponse> deserialized(round_trip(ver, msg, 11));
569 EXPECT_EQ(3U, deserialized->key_data_length);
570 EXPECT_EQ(0, memcmp("foo", deserialized->key_data, 3));
571 }
572 }
573
TEST(RoundTrip,DeleteKeyRequest)574 TEST(RoundTrip, DeleteKeyRequest) {
575 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
576 DeleteKeyRequest msg(ver);
577 msg.SetKeyMaterial("foo", 3);
578
579 UniquePtr<DeleteKeyRequest> deserialized(round_trip(ver, msg, 7));
580 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
581 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
582 }
583 }
584
TEST(RoundTrip,DeleteAllKeysRequest)585 TEST(RoundTrip, DeleteAllKeysRequest) {
586 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
587 DeleteAllKeysRequest msg(ver);
588 UniquePtr<DeleteAllKeysRequest> deserialized(round_trip(ver, msg, 0));
589 }
590 }
591
TEST(RoundTrip,GetVersionRequest)592 TEST(RoundTrip, GetVersionRequest) {
593 GetVersionRequest msg(0);
594
595 size_t size = msg.SerializedSize();
596 ASSERT_EQ(0U, size);
597
598 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
599 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
600
601 GetVersionRequest deserialized;
602 const uint8_t* p = buf.get();
603 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
604 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
605 }
606
TEST(RoundTrip,GetVersionResponse)607 TEST(RoundTrip, GetVersionResponse) {
608 GetVersionResponse msg(0);
609 msg.error = KM_ERROR_OK;
610 msg.major_ver = 9;
611 msg.minor_ver = 98;
612 msg.subminor_ver = 38;
613
614 size_t size = msg.SerializedSize();
615 ASSERT_EQ(7U, size);
616
617 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
618 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
619
620 GetVersionResponse deserialized;
621 const uint8_t* p = buf.get();
622 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
623 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
624 EXPECT_EQ(9U, msg.major_ver);
625 EXPECT_EQ(98U, msg.minor_ver);
626 EXPECT_EQ(38U, msg.subminor_ver);
627 }
628
TEST(RoundTrip,GetVersion2Request)629 TEST(RoundTrip, GetVersion2Request) {
630 GetVersion2Request msg;
631
632 msg.max_message_version = 0xDEADBEEF;
633 size_t size = msg.SerializedSize();
634 ASSERT_EQ(4U, size);
635
636 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
637 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
638
639 GetVersion2Request deserialized;
640 const uint8_t* p = buf.get();
641 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
642 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
643 EXPECT_EQ(0xDEADBEEF, msg.max_message_version);
644 }
645
TEST(RoundTrip,GetVersion2Response)646 TEST(RoundTrip, GetVersion2Response) {
647 GetVersion2Response msg;
648 msg.error = KM_ERROR_OK;
649 msg.km_version = KmVersion::KEYMINT_1;
650 msg.km_date = 20121900;
651
652 size_t size = msg.SerializedSize();
653 ASSERT_EQ(16U, size);
654
655 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
656 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
657
658 GetVersion2Response deserialized;
659 const uint8_t* p = buf.get();
660 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
661 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
662 EXPECT_EQ(KmVersion::KEYMINT_1, msg.km_version);
663 EXPECT_EQ(20121900U, msg.km_date);
664 }
665
TEST(RoundTrip,ConfigureRequest)666 TEST(RoundTrip, ConfigureRequest) {
667 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
668 ConfigureRequest req(ver);
669 req.os_version = 1;
670 req.os_patchlevel = 1;
671
672 UniquePtr<ConfigureRequest> deserialized(round_trip(ver, req, 8));
673 EXPECT_EQ(deserialized->os_version, req.os_version);
674 EXPECT_EQ(deserialized->os_patchlevel, req.os_patchlevel);
675 }
676 }
677
TEST(RoundTrip,ConfigureResponse)678 TEST(RoundTrip, ConfigureResponse) {
679 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
680 ConfigureResponse rsp(ver);
681 UniquePtr<ConfigureResponse> deserialized(round_trip(ver, rsp, 4));
682 }
683 }
684
TEST(RoundTrip,ConfigureVendorPatchlevelRequest)685 TEST(RoundTrip, ConfigureVendorPatchlevelRequest) {
686 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
687 ConfigureVendorPatchlevelRequest req(ver);
688 req.vendor_patchlevel = 2;
689
690 UniquePtr<ConfigureVendorPatchlevelRequest> deserialized(round_trip(ver, req, 4));
691 EXPECT_EQ(deserialized->vendor_patchlevel, req.vendor_patchlevel);
692 }
693 }
694
TEST(RoundTrip,ConfigureVendorPatchlevelResponse)695 TEST(RoundTrip, ConfigureVendorPatchlevelResponse) {
696 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
697 ConfigureVendorPatchlevelResponse rsp(ver);
698 UniquePtr<ConfigureVendorPatchlevelResponse> deserialized(round_trip(ver, rsp, 4));
699 }
700 }
701
TEST(RoundTrip,ConfigureBootPatchlevelRequest)702 TEST(RoundTrip, ConfigureBootPatchlevelRequest) {
703 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
704 ConfigureBootPatchlevelRequest req(ver);
705 req.boot_patchlevel = 2;
706
707 UniquePtr<ConfigureBootPatchlevelRequest> deserialized(round_trip(ver, req, 4));
708 EXPECT_EQ(deserialized->boot_patchlevel, req.boot_patchlevel);
709 }
710 }
711
TEST(RoundTrip,ConfigureBootPatchlevelResponse)712 TEST(RoundTrip, ConfigureBootPatchlevelResponse) {
713 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
714 ConfigureBootPatchlevelResponse rsp(ver);
715 UniquePtr<ConfigureBootPatchlevelResponse> deserialized(round_trip(ver, rsp, 4));
716 }
717 }
718
TEST(RoundTrip,AddEntropyRequest)719 TEST(RoundTrip, AddEntropyRequest) {
720 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
721 AddEntropyRequest msg(ver);
722 msg.random_data.Reinitialize("foo", 3);
723
724 UniquePtr<AddEntropyRequest> deserialized(round_trip(ver, msg, 7));
725 EXPECT_EQ(3U, deserialized->random_data.available_read());
726 EXPECT_EQ(0, memcmp("foo", deserialized->random_data.peek_read(), 3));
727 }
728 }
729
TEST(RoundTrip,AbortOperationRequest)730 TEST(RoundTrip, AbortOperationRequest) {
731 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
732 AbortOperationRequest msg(ver);
733 UniquePtr<AbortOperationRequest> deserialized(round_trip(ver, msg, 8));
734 }
735 }
736
TEST(RoundTrip,AttestKeyRequest)737 TEST(RoundTrip, AttestKeyRequest) {
738 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
739 AttestKeyRequest msg(ver);
740 msg.SetKeyMaterial("foo", 3);
741 msg.attest_params.Reinitialize(params, array_length(params));
742
743 UniquePtr<AttestKeyRequest> deserialized(round_trip(ver, msg, 85));
744 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
745 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
746 EXPECT_EQ(msg.attest_params, deserialized->attest_params);
747 }
748 }
749
TEST(RoundTrip,AttestKeyResponse)750 TEST(RoundTrip, AttestKeyResponse) {
751 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
752 AttestKeyResponse msg(ver);
753 msg.error = KM_ERROR_OK;
754 msg.certificate_chain = CertificateChain(3);
755 EXPECT_TRUE(!!msg.certificate_chain.entries);
756 msg.certificate_chain.entries[0] = {dup_buffer("foo", 3), 3};
757 msg.certificate_chain.entries[1] = {dup_buffer("bar", 3), 3};
758 msg.certificate_chain.entries[2] = {dup_buffer("baz", 3), 3};
759
760 UniquePtr<AttestKeyResponse> deserialized(round_trip(ver, msg, 29));
761 keymaster_cert_chain_t* chain = &deserialized->certificate_chain;
762
763 EXPECT_NE(nullptr, chain->entries);
764 EXPECT_EQ(3U, chain->entry_count);
765 EXPECT_EQ(3U, chain->entries[0].data_length);
766 EXPECT_EQ(0, memcmp("foo", chain->entries[0].data, 3));
767 EXPECT_EQ(3U, chain->entries[1].data_length);
768 EXPECT_EQ(0, memcmp("bar", chain->entries[1].data, 3));
769 EXPECT_EQ(3U, chain->entries[2].data_length);
770 EXPECT_EQ(0, memcmp("baz", chain->entries[2].data, 3));
771 }
772 }
773
TEST(RoundTrip,UpgradeKeyRequest)774 TEST(RoundTrip, UpgradeKeyRequest) {
775 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
776 UpgradeKeyRequest msg(ver);
777 msg.SetKeyMaterial("foo", 3);
778 msg.upgrade_params.Reinitialize(params, array_length(params));
779
780 UniquePtr<UpgradeKeyRequest> deserialized(round_trip(ver, msg, 85));
781 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
782 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
783 EXPECT_EQ(msg.upgrade_params, deserialized->upgrade_params);
784 }
785 }
786
TEST(RoundTrip,UpgradeKeyResponse)787 TEST(RoundTrip, UpgradeKeyResponse) {
788 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
789 UpgradeKeyResponse req(ver);
790 req.error = KM_ERROR_OK;
791 req.upgraded_key.key_material = dup_array(TEST_DATA);
792 req.upgraded_key.key_material_size = array_length(TEST_DATA);
793
794 UniquePtr<UpgradeKeyResponse> deserialized(round_trip(ver, req, 19));
795 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
796 EXPECT_EQ(req.upgraded_key.key_material_size, deserialized->upgraded_key.key_material_size);
797 EXPECT_EQ(0, memcmp(req.upgraded_key.key_material, deserialized->upgraded_key.key_material,
798 req.upgraded_key.key_material_size));
799 }
800 }
801
TEST(RoundTrip,GenerateTimestampTokenRequest)802 TEST(RoundTrip, GenerateTimestampTokenRequest) {
803 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
804 GenerateTimestampTokenRequest msg(ver);
805 msg.challenge = 1;
806 UniquePtr<GenerateTimestampTokenRequest> deserialized(round_trip(ver, msg, 8));
807 EXPECT_EQ(1U, deserialized->challenge);
808 }
809 }
810
TEST(RoundTrip,GenerateTimestampTokenResponse)811 TEST(RoundTrip, GenerateTimestampTokenResponse) {
812 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
813 GenerateTimestampTokenResponse msg(ver);
814 msg.error = KM_ERROR_OK;
815 msg.token.challenge = 1;
816 msg.token.timestamp = 2;
817 msg.token.security_level = KM_SECURITY_LEVEL_SOFTWARE;
818 msg.token.mac.data = dup_array(TEST_DATA);
819 msg.token.mac.data_length = array_length(TEST_DATA);
820 UniquePtr<GenerateTimestampTokenResponse> deserialized(round_trip(ver, msg, 39));
821 EXPECT_EQ(1U, deserialized->token.challenge);
822 EXPECT_EQ(2U, deserialized->token.timestamp);
823 EXPECT_EQ(KM_SECURITY_LEVEL_SOFTWARE, deserialized->token.security_level);
824 EXPECT_EQ(msg.token.mac.data_length, deserialized->token.mac.data_length);
825 EXPECT_EQ(
826 0, memcmp(msg.token.mac.data, deserialized->token.mac.data, msg.token.mac.data_length));
827 }
828 }
829
830 #define SET_ATTESTATION_ID(x) msg.x.Reinitialize(#x, strlen(#x))
831
check_id(const Buffer & id,const char * value)832 void check_id(const Buffer& id, const char* value) {
833 auto len = strlen(value);
834 EXPECT_EQ(id.available_read(), len) << "On " << value;
835 EXPECT_TRUE(memcmp(id.peek_read(), value, len) == 0) << "On " << value;
836 }
837
838 #define CHECK_ID(x) check_id(deserialized->x, #x);
839
TEST(RoundTrip,SetAttestationIdsRequest)840 TEST(RoundTrip, SetAttestationIdsRequest) {
841 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
842 SetAttestationIdsRequest msg(ver);
843 SET_ATTESTATION_ID(brand);
844 SET_ATTESTATION_ID(device);
845 SET_ATTESTATION_ID(product);
846 SET_ATTESTATION_ID(serial);
847 SET_ATTESTATION_ID(imei);
848 SET_ATTESTATION_ID(meid);
849 SET_ATTESTATION_ID(manufacturer);
850 SET_ATTESTATION_ID(model);
851
852 UniquePtr<SetAttestationIdsRequest> deserialized(round_trip(ver, msg, 81));
853 ASSERT_TRUE(deserialized);
854 CHECK_ID(brand);
855 CHECK_ID(device);
856 CHECK_ID(product);
857 CHECK_ID(serial);
858 CHECK_ID(imei);
859 CHECK_ID(model);
860 }
861 }
862
863 uint8_t msgbuf[] = {
864 220, 88, 183, 255, 71, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
865 0, 173, 0, 0, 0, 228, 174, 98, 187, 191, 135, 253, 200, 51, 230, 114, 247, 151, 109,
866 237, 79, 87, 32, 94, 5, 204, 46, 154, 30, 91, 6, 103, 148, 254, 129, 65, 171, 228,
867 167, 224, 163, 9, 15, 206, 90, 58, 11, 205, 55, 211, 33, 87, 178, 149, 91, 28, 236,
868 218, 112, 231, 34, 82, 82, 134, 103, 137, 115, 27, 156, 102, 159, 220, 226, 89, 42, 25,
869 37, 9, 84, 239, 76, 161, 198, 72, 167, 163, 39, 91, 148, 191, 17, 191, 87, 169, 179,
870 136, 10, 194, 154, 4, 40, 107, 109, 61, 161, 20, 176, 247, 13, 214, 106, 229, 45, 17,
871 5, 60, 189, 64, 39, 166, 208, 14, 57, 25, 140, 148, 25, 177, 246, 189, 43, 181, 88,
872 204, 29, 126, 224, 100, 143, 93, 60, 57, 249, 55, 0, 87, 83, 227, 224, 166, 59, 214,
873 81, 144, 129, 58, 6, 57, 46, 254, 232, 41, 220, 209, 230, 167, 138, 158, 94, 180, 125,
874 247, 26, 162, 116, 238, 202, 187, 100, 65, 13, 180, 44, 245, 159, 83, 161, 176, 58, 72,
875 236, 109, 105, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
876 0, 11, 0, 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0,
877 0, 32, 3, 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0,
878 1, 0, 0, 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112,
879 1, 246, 1, 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145,
880 1, 0, 96, 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0,
881 0, 0, 0, 0, 190, 2, 0, 16, 1, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
882 0, 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 0, 11, 0,
883 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0, 0, 32, 3,
884 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0, 1, 0, 0,
885 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112, 1, 246, 1,
886 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145, 1, 0, 96,
887 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0, 0, 0, 0,
888 0, 190, 2, 0, 16, 1, 0, 0, 0,
889 };
890
891 /*
892 * These tests don't have any assertions or expectations. They just try to parse garbage, to see if
893 * the result will be a crash. This is especially informative when run under Valgrind memcheck.
894 */
895
parse_garbage()896 template <typename Message> void parse_garbage() {
897 for (int32_t ver = 0; ver <= kMaxMessageVersion; ++ver) {
898 Message msg(ver);
899 const uint8_t* end = msgbuf + array_length(msgbuf);
900 for (size_t i = 0; i < array_length(msgbuf); ++i) {
901 const uint8_t* begin = msgbuf + i;
902 const uint8_t* p = begin;
903 msg.Deserialize(&p, end);
904 }
905 }
906
907 time_t now = time(nullptr);
908 std::cout << "Seeding rand() with " << now << " for fuzz test." << std::endl;
909 srand(now);
910
911 // Fill large buffer with random bytes.
912 const int kBufSize = 10000;
913 UniquePtr<uint8_t[]> buf(new uint8_t[kBufSize]);
914 for (size_t i = 0; i < kBufSize; ++i)
915 buf[i] = static_cast<uint8_t>(rand());
916
917 for (uint32_t ver = 0; ver < kMaxMessageVersion; ++ver) {
918 Message msg(ver);
919 const uint8_t* end = buf.get() + kBufSize;
920 for (size_t i = 0; i < kBufSize; ++i) {
921 const uint8_t* begin = buf.get() + i;
922 const uint8_t* p = begin;
923 msg.Deserialize(&p, end);
924 }
925 }
926 }
927
928 #define GARBAGE_TEST(Message) \
929 TEST(GarbageTest, Message) { parse_garbage<Message>(); }
930
931 GARBAGE_TEST(AbortOperationRequest);
932 GARBAGE_TEST(EmptyKeymasterResponse);
933 GARBAGE_TEST(AddEntropyRequest);
934 GARBAGE_TEST(BeginOperationRequest);
935 GARBAGE_TEST(BeginOperationResponse);
936 GARBAGE_TEST(DeleteAllKeysRequest);
937 GARBAGE_TEST(DeleteKeyRequest);
938 GARBAGE_TEST(ExportKeyRequest);
939 GARBAGE_TEST(ExportKeyResponse);
940 GARBAGE_TEST(FinishOperationRequest);
941 GARBAGE_TEST(FinishOperationResponse);
942 GARBAGE_TEST(GenerateKeyRequest);
943 GARBAGE_TEST(GenerateKeyResponse);
944 GARBAGE_TEST(GetKeyCharacteristicsRequest);
945 GARBAGE_TEST(GetKeyCharacteristicsResponse);
946 GARBAGE_TEST(ImportKeyRequest);
947 GARBAGE_TEST(ImportKeyResponse);
948 GARBAGE_TEST(UpdateOperationRequest);
949 GARBAGE_TEST(UpdateOperationResponse);
950 GARBAGE_TEST(AttestKeyRequest);
951 GARBAGE_TEST(AttestKeyResponse);
952 GARBAGE_TEST(UpgradeKeyRequest);
953 GARBAGE_TEST(UpgradeKeyResponse);
954 GARBAGE_TEST(GenerateTimestampTokenRequest);
955 GARBAGE_TEST(GenerateTimestampTokenResponse);
956 GARBAGE_TEST(SetAttestationIdsRequest);
957
958 } // namespace test
959
960 } // namespace keymaster
961