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,GenerateCsrV2Request)252 TEST(RoundTrip, GenerateCsrV2Request) {
253 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
254 GenerateCsrV2Request req(ver);
255 EXPECT_TRUE(req.InitKeysToSign(2));
256 for (size_t i = 0; i < req.num_keys; i++) {
257 req.SetKeyToSign(i, dup_array(TEST_DATA), array_length(TEST_DATA));
258 }
259 req.SetChallenge(dup_array(TEST_DATA), array_length(TEST_DATA));
260 UniquePtr<GenerateCsrV2Request> deserialized(round_trip(ver, req, 49));
261 EXPECT_EQ(deserialized->num_keys, req.num_keys);
262 for (int i = 0; i < (int)req.num_keys; i++) {
263 EXPECT_EQ(deserialized->keys_to_sign_array[i].data_length,
264 req.keys_to_sign_array[i].data_length);
265 EXPECT_EQ(0, std::memcmp(deserialized->keys_to_sign_array[i].data,
266 req.keys_to_sign_array[i].data,
267 req.keys_to_sign_array[i].data_length));
268 }
269 EXPECT_EQ(deserialized->challenge.data_length, req.challenge.data_length);
270 EXPECT_EQ(0, std::memcmp(deserialized->challenge.data, req.challenge.data,
271 req.challenge.data_length));
272 }
273 }
274
TEST(RoundTrip,GenerateCsrV2Response)275 TEST(RoundTrip, GenerateCsrV2Response) {
276 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
277 GenerateCsrV2Response rsp(ver);
278 rsp.error = KM_ERROR_OK;
279 rsp.csr.data = dup_array(TEST_DATA);
280 rsp.csr.data_length = array_length(TEST_DATA);
281
282 UniquePtr<GenerateCsrV2Response> deserialized;
283 deserialized.reset(round_trip(ver, rsp, 19));
284
285 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
286 EXPECT_EQ(deserialized->csr.data_length, rsp.csr.data_length);
287 EXPECT_EQ(0,
288 std::memcmp(deserialized->csr.data, rsp.csr.data, deserialized->csr.data_length));
289 }
290 }
291
TEST(RoundTrip,GetKeyCharacteristicsRequest)292 TEST(RoundTrip, GetKeyCharacteristicsRequest) {
293 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
294 GetKeyCharacteristicsRequest req(ver);
295 req.additional_params.Reinitialize(params, array_length(params));
296 req.SetKeyMaterial("foo", 3);
297
298 UniquePtr<GetKeyCharacteristicsRequest> deserialized(round_trip(ver, req, 85));
299 EXPECT_EQ(7U, deserialized->additional_params.size());
300 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
301 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
302 }
303 }
304
TEST(RoundTrip,GetKeyCharacteristicsResponse)305 TEST(RoundTrip, GetKeyCharacteristicsResponse) {
306 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
307 GetKeyCharacteristicsResponse msg(ver);
308 msg.error = KM_ERROR_OK;
309 msg.enforced.Reinitialize(params, array_length(params));
310 msg.unenforced.Reinitialize(params, array_length(params));
311
312 UniquePtr<GetKeyCharacteristicsResponse> deserialized(round_trip(ver, msg, 160));
313 EXPECT_EQ(msg.enforced, deserialized->enforced);
314 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
315 }
316 }
317
TEST(RoundTrip,BeginOperationRequest)318 TEST(RoundTrip, BeginOperationRequest) {
319 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
320 BeginOperationRequest msg(ver);
321 msg.purpose = KM_PURPOSE_SIGN;
322 msg.SetKeyMaterial("foo", 3);
323 msg.additional_params.Reinitialize(params, array_length(params));
324
325 UniquePtr<BeginOperationRequest> deserialized(round_trip(ver, msg, 89));
326 EXPECT_EQ(KM_PURPOSE_SIGN, deserialized->purpose);
327 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
328 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
329 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
330 }
331 }
332
TEST(RoundTrip,BeginOperationResponse)333 TEST(RoundTrip, BeginOperationResponse) {
334 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
335 BeginOperationResponse msg(ver);
336 msg.error = KM_ERROR_OK;
337 msg.op_handle = 0xDEADBEEF;
338 msg.output_params.push_back(Authorization(TAG_NONCE, "foo", 3));
339
340 UniquePtr<BeginOperationResponse> deserialized;
341 switch (ver) {
342 case 0:
343 deserialized.reset(round_trip(ver, msg, 12));
344 break;
345 case 1:
346 case 2:
347 case 3:
348 case 4:
349 deserialized.reset(round_trip(ver, msg, 39));
350 break;
351 default:
352 FAIL();
353 }
354
355 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
356 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
357
358 switch (ver) {
359 case 0:
360 EXPECT_EQ(0U, deserialized->output_params.size());
361 break;
362 case 1:
363 case 2:
364 case 3:
365 case 4:
366 EXPECT_EQ(msg.output_params, deserialized->output_params);
367 break;
368 default:
369 FAIL();
370 }
371 }
372 }
373
TEST(RoundTrip,BeginOperationResponseError)374 TEST(RoundTrip, BeginOperationResponseError) {
375 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
376 BeginOperationResponse msg(ver);
377 msg.error = KM_ERROR_INVALID_OPERATION_HANDLE;
378 msg.op_handle = 0xDEADBEEF;
379
380 UniquePtr<BeginOperationResponse> deserialized(round_trip(ver, msg, 4));
381 EXPECT_EQ(KM_ERROR_INVALID_OPERATION_HANDLE, deserialized->error);
382 }
383 }
384
TEST(RoundTrip,UpdateOperationRequest)385 TEST(RoundTrip, UpdateOperationRequest) {
386 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
387 UpdateOperationRequest msg(ver);
388 msg.op_handle = 0xDEADBEEF;
389 msg.input.Reinitialize("foo", 3);
390
391 UniquePtr<UpdateOperationRequest> deserialized;
392 switch (ver) {
393 case 0:
394 deserialized.reset(round_trip(ver, msg, 15));
395 break;
396 case 1:
397 case 2:
398 case 3:
399 case 4:
400 deserialized.reset(round_trip(ver, msg, 27));
401 break;
402 default:
403 FAIL();
404 }
405 EXPECT_EQ(3U, deserialized->input.available_read());
406 EXPECT_EQ(0, memcmp(deserialized->input.peek_read(), "foo", 3));
407 }
408 }
409
TEST(RoundTrip,UpdateOperationResponse)410 TEST(RoundTrip, UpdateOperationResponse) {
411 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
412 UpdateOperationResponse msg(ver);
413 msg.error = KM_ERROR_OK;
414 msg.output.Reinitialize("foo", 3);
415 msg.input_consumed = 99;
416 msg.output_params.push_back(TAG_APPLICATION_ID, "bar", 3);
417
418 UniquePtr<UpdateOperationResponse> deserialized;
419 switch (ver) {
420 case 0:
421 deserialized.reset(round_trip(ver, msg, 11));
422 break;
423 case 1:
424 deserialized.reset(round_trip(ver, msg, 15));
425 break;
426 case 2:
427 case 3:
428 case 4:
429 deserialized.reset(round_trip(ver, msg, 42));
430 break;
431 default:
432 FAIL();
433 }
434 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
435 EXPECT_EQ(3U, deserialized->output.available_read());
436 EXPECT_EQ(0, memcmp(deserialized->output.peek_read(), "foo", 3));
437
438 switch (ver) {
439 case 0:
440 EXPECT_EQ(0U, deserialized->input_consumed);
441 break;
442 case 1:
443 EXPECT_EQ(99U, deserialized->input_consumed);
444 break;
445 case 2:
446 case 3:
447 case 4:
448 EXPECT_EQ(99U, deserialized->input_consumed);
449 EXPECT_EQ(1U, deserialized->output_params.size());
450 break;
451 default:
452 FAIL();
453 }
454 }
455 }
456
TEST(RoundTrip,FinishOperationRequest)457 TEST(RoundTrip, FinishOperationRequest) {
458 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
459 FinishOperationRequest msg(ver);
460 msg.op_handle = 0xDEADBEEF;
461 msg.signature.Reinitialize("bar", 3);
462 msg.input.Reinitialize("baz", 3);
463
464 UniquePtr<FinishOperationRequest> deserialized;
465 switch (ver) {
466 case 0:
467 deserialized.reset(round_trip(ver, msg, 15));
468 break;
469 case 1:
470 case 2:
471 deserialized.reset(round_trip(ver, msg, 27));
472 break;
473 case 3:
474 case 4:
475 deserialized.reset(round_trip(ver, msg, 34));
476 break;
477 default:
478 FAIL();
479 }
480 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
481 EXPECT_EQ(3U, deserialized->signature.available_read());
482 EXPECT_EQ(0, memcmp(deserialized->signature.peek_read(), "bar", 3));
483 }
484 }
485
TEST(Round_Trip,FinishOperationResponse)486 TEST(Round_Trip, FinishOperationResponse) {
487 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
488 FinishOperationResponse msg(ver);
489 msg.error = KM_ERROR_OK;
490 msg.output.Reinitialize("foo", 3);
491
492 UniquePtr<FinishOperationResponse> deserialized;
493 switch (ver) {
494 case 0:
495 case 1:
496 deserialized.reset(round_trip(ver, msg, 11));
497 break;
498 case 2:
499 case 3:
500 case 4:
501 deserialized.reset(round_trip(ver, msg, 23));
502 break;
503 default:
504 FAIL();
505 }
506 EXPECT_EQ(msg.error, deserialized->error);
507 EXPECT_EQ(msg.output.available_read(), deserialized->output.available_read());
508 EXPECT_EQ(0, memcmp(msg.output.peek_read(), deserialized->output.peek_read(),
509 msg.output.available_read()));
510 }
511 }
512
TEST(RoundTrip,ImportKeyRequest)513 TEST(RoundTrip, ImportKeyRequest) {
514 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
515 ImportKeyRequest msg(ver);
516 msg.key_description.Reinitialize(params, array_length(params));
517 msg.key_format = KM_KEY_FORMAT_X509;
518 msg.key_data = KeymasterKeyBlob(reinterpret_cast<const uint8_t*>("foo"), 3);
519 msg.attestation_signing_key_blob =
520 KeymasterKeyBlob(reinterpret_cast<const uint8_t*>("bar"), 3);
521 msg.attest_key_params.Reinitialize(params, array_length(params));
522 msg.issuer_subject = KeymasterBlob(reinterpret_cast<const uint8_t*>("bar"), 3);
523
524 UniquePtr<ImportKeyRequest> deserialized(round_trip(ver, msg, ver < 4 ? 89 : 181));
525 EXPECT_EQ(msg.key_description, deserialized->key_description);
526 EXPECT_EQ(msg.key_format, deserialized->key_format);
527 EXPECT_EQ(msg.key_data.key_material_size, deserialized->key_data.key_material_size);
528 EXPECT_EQ(0, memcmp(msg.key_data.key_material, deserialized->key_data.key_material,
529 msg.key_data.key_material_size));
530 if (ver < 4) {
531 EXPECT_EQ(0U, deserialized->attestation_signing_key_blob.key_material_size);
532 } else {
533 EXPECT_EQ(3U, deserialized->attestation_signing_key_blob.key_material_size);
534 EXPECT_EQ(0, memcmp(msg.attestation_signing_key_blob.key_material,
535 deserialized->attestation_signing_key_blob.key_material,
536 msg.attestation_signing_key_blob.key_material_size));
537 EXPECT_EQ(deserialized->attest_key_params, msg.attest_key_params);
538 EXPECT_EQ(0, memcmp(msg.issuer_subject.data, deserialized->issuer_subject.data,
539 deserialized->issuer_subject.data_length));
540 }
541 }
542 }
543
TEST(RoundTrip,ImportKeyResponse)544 TEST(RoundTrip, ImportKeyResponse) {
545 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
546 ImportKeyResponse msg(ver);
547 msg.error = KM_ERROR_OK;
548 msg.SetKeyMaterial("foo", 3);
549 msg.enforced.Reinitialize(params, array_length(params));
550 msg.unenforced.Reinitialize(params, array_length(params));
551
552 msg.certificate_chain = CertificateChain(3);
553 msg.certificate_chain.entries[0] = {dup_buffer("foo", 3), 3};
554 msg.certificate_chain.entries[1] = {dup_buffer("bar", 3), 3};
555 msg.certificate_chain.entries[2] = {dup_buffer("baz", 3), 3};
556
557 UniquePtr<ImportKeyResponse> deserialized;
558 if (ver < 4) {
559 deserialized.reset(round_trip(ver, msg, 167));
560 } else {
561 deserialized.reset(round_trip(ver, msg, 192));
562 }
563
564 EXPECT_EQ(msg.error, deserialized->error);
565 EXPECT_EQ(msg.key_blob.key_material_size, deserialized->key_blob.key_material_size);
566 EXPECT_EQ(0, memcmp(msg.key_blob.key_material, deserialized->key_blob.key_material,
567 msg.key_blob.key_material_size));
568 EXPECT_EQ(msg.enforced, deserialized->enforced);
569 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
570
571 keymaster_cert_chain_t* chain = &deserialized->certificate_chain;
572 if (ver < 4) {
573 EXPECT_EQ(nullptr, chain->entries);
574 } else {
575 EXPECT_NE(nullptr, chain->entries);
576 EXPECT_EQ(3U, chain->entry_count);
577 EXPECT_EQ(3U, chain->entries[0].data_length);
578 EXPECT_EQ(0, memcmp("foo", chain->entries[0].data, 3));
579 EXPECT_EQ(3U, chain->entries[1].data_length);
580 EXPECT_EQ(0, memcmp("bar", chain->entries[1].data, 3));
581 EXPECT_EQ(3U, chain->entries[2].data_length);
582 EXPECT_EQ(0, memcmp("baz", chain->entries[2].data, 3));
583 }
584 }
585 }
586
TEST(RoundTrip,ExportKeyRequest)587 TEST(RoundTrip, ExportKeyRequest) {
588 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
589 ExportKeyRequest msg(ver);
590 msg.additional_params.Reinitialize(params, array_length(params));
591 msg.key_format = KM_KEY_FORMAT_X509;
592 msg.SetKeyMaterial("foo", 3);
593
594 UniquePtr<ExportKeyRequest> deserialized(round_trip(ver, msg, 89));
595 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
596 EXPECT_EQ(msg.key_format, deserialized->key_format);
597 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
598 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
599 }
600 }
601
TEST(RoundTrip,ExportKeyResponse)602 TEST(RoundTrip, ExportKeyResponse) {
603 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
604 ExportKeyResponse msg(ver);
605 msg.error = KM_ERROR_OK;
606 msg.SetKeyMaterial("foo", 3);
607
608 UniquePtr<ExportKeyResponse> deserialized(round_trip(ver, msg, 11));
609 EXPECT_EQ(3U, deserialized->key_data_length);
610 EXPECT_EQ(0, memcmp("foo", deserialized->key_data, 3));
611 }
612 }
613
TEST(RoundTrip,DeleteKeyRequest)614 TEST(RoundTrip, DeleteKeyRequest) {
615 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
616 DeleteKeyRequest msg(ver);
617 msg.SetKeyMaterial("foo", 3);
618
619 UniquePtr<DeleteKeyRequest> deserialized(round_trip(ver, msg, 7));
620 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
621 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
622 }
623 }
624
TEST(RoundTrip,DeleteAllKeysRequest)625 TEST(RoundTrip, DeleteAllKeysRequest) {
626 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
627 DeleteAllKeysRequest msg(ver);
628 UniquePtr<DeleteAllKeysRequest> deserialized(round_trip(ver, msg, 0));
629 }
630 }
631
TEST(RoundTrip,GetVersionRequest)632 TEST(RoundTrip, GetVersionRequest) {
633 GetVersionRequest msg(0);
634
635 size_t size = msg.SerializedSize();
636 ASSERT_EQ(0U, size);
637
638 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
639 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
640
641 GetVersionRequest deserialized;
642 const uint8_t* p = buf.get();
643 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
644 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
645 }
646
TEST(RoundTrip,GetVersionResponse)647 TEST(RoundTrip, GetVersionResponse) {
648 GetVersionResponse msg(0);
649 msg.error = KM_ERROR_OK;
650 msg.major_ver = 9;
651 msg.minor_ver = 98;
652 msg.subminor_ver = 38;
653
654 size_t size = msg.SerializedSize();
655 ASSERT_EQ(7U, size);
656
657 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
658 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
659
660 GetVersionResponse deserialized;
661 const uint8_t* p = buf.get();
662 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
663 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
664 EXPECT_EQ(9U, msg.major_ver);
665 EXPECT_EQ(98U, msg.minor_ver);
666 EXPECT_EQ(38U, msg.subminor_ver);
667 }
668
TEST(RoundTrip,GetVersion2Request)669 TEST(RoundTrip, GetVersion2Request) {
670 GetVersion2Request msg;
671
672 msg.max_message_version = 0xDEADBEEF;
673 size_t size = msg.SerializedSize();
674 ASSERT_EQ(4U, size);
675
676 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
677 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
678
679 GetVersion2Request deserialized;
680 const uint8_t* p = buf.get();
681 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
682 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
683 EXPECT_EQ(0xDEADBEEF, msg.max_message_version);
684 }
685
TEST(RoundTrip,GetVersion2Response)686 TEST(RoundTrip, GetVersion2Response) {
687 GetVersion2Response msg;
688 msg.error = KM_ERROR_OK;
689 msg.km_version = KmVersion::KEYMINT_1;
690 msg.km_date = 20121900;
691
692 size_t size = msg.SerializedSize();
693 ASSERT_EQ(16U, size);
694
695 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
696 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
697
698 GetVersion2Response deserialized;
699 const uint8_t* p = buf.get();
700 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
701 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
702 EXPECT_EQ(KmVersion::KEYMINT_1, msg.km_version);
703 EXPECT_EQ(20121900U, msg.km_date);
704 }
705
TEST(RoundTrip,ConfigureRequest)706 TEST(RoundTrip, ConfigureRequest) {
707 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
708 ConfigureRequest req(ver);
709 req.os_version = 1;
710 req.os_patchlevel = 1;
711
712 UniquePtr<ConfigureRequest> deserialized(round_trip(ver, req, 8));
713 EXPECT_EQ(deserialized->os_version, req.os_version);
714 EXPECT_EQ(deserialized->os_patchlevel, req.os_patchlevel);
715 }
716 }
717
TEST(RoundTrip,ConfigureResponse)718 TEST(RoundTrip, ConfigureResponse) {
719 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
720 ConfigureResponse rsp(ver);
721 UniquePtr<ConfigureResponse> deserialized(round_trip(ver, rsp, 4));
722 }
723 }
724
TEST(RoundTrip,ConfigureVendorPatchlevelRequest)725 TEST(RoundTrip, ConfigureVendorPatchlevelRequest) {
726 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
727 ConfigureVendorPatchlevelRequest req(ver);
728 req.vendor_patchlevel = 2;
729
730 UniquePtr<ConfigureVendorPatchlevelRequest> deserialized(round_trip(ver, req, 4));
731 EXPECT_EQ(deserialized->vendor_patchlevel, req.vendor_patchlevel);
732 }
733 }
734
TEST(RoundTrip,ConfigureVendorPatchlevelResponse)735 TEST(RoundTrip, ConfigureVendorPatchlevelResponse) {
736 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
737 ConfigureVendorPatchlevelResponse rsp(ver);
738 UniquePtr<ConfigureVendorPatchlevelResponse> deserialized(round_trip(ver, rsp, 4));
739 }
740 }
741
TEST(RoundTrip,ConfigureBootPatchlevelRequest)742 TEST(RoundTrip, ConfigureBootPatchlevelRequest) {
743 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
744 ConfigureBootPatchlevelRequest req(ver);
745 req.boot_patchlevel = 2;
746
747 UniquePtr<ConfigureBootPatchlevelRequest> deserialized(round_trip(ver, req, 4));
748 EXPECT_EQ(deserialized->boot_patchlevel, req.boot_patchlevel);
749 }
750 }
751
TEST(RoundTrip,ConfigureBootPatchlevelResponse)752 TEST(RoundTrip, ConfigureBootPatchlevelResponse) {
753 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
754 ConfigureBootPatchlevelResponse rsp(ver);
755 UniquePtr<ConfigureBootPatchlevelResponse> deserialized(round_trip(ver, rsp, 4));
756 }
757 }
758
TEST(RoundTrip,ConfigureVerifiedBootInfoRequest)759 TEST(RoundTrip, ConfigureVerifiedBootInfoRequest) {
760 for (int32_t ver = 0; ver <= kMaxMessageVersion; ++ver) {
761 ConfigureVerifiedBootInfoRequest req(ver, "super", "duper", {1, 2, 3, 4, 5, 6});
762
763 UniquePtr<ConfigureVerifiedBootInfoRequest> deserialized(round_trip(ver, req, 28));
764 ASSERT_NE(deserialized, nullptr);
765 EXPECT_EQ(deserialized->boot_state, req.boot_state);
766 EXPECT_EQ(deserialized->bootloader_state, req.bootloader_state);
767 EXPECT_EQ(deserialized->vbmeta_digest, req.vbmeta_digest);
768 }
769 }
770
TEST(RoundTrip,ConfigureVerifiedBootInfoResponse)771 TEST(RoundTrip, ConfigureVerifiedBootInfoResponse) {
772 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
773 ConfigureVerifiedBootInfoResponse rsp(ver);
774 UniquePtr<ConfigureVerifiedBootInfoResponse> deserialized(round_trip(ver, rsp, 4));
775 }
776 }
777
TEST(RoundTrip,AddEntropyRequest)778 TEST(RoundTrip, AddEntropyRequest) {
779 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
780 AddEntropyRequest msg(ver);
781 msg.random_data.Reinitialize("foo", 3);
782
783 UniquePtr<AddEntropyRequest> deserialized(round_trip(ver, msg, 7));
784 EXPECT_EQ(3U, deserialized->random_data.available_read());
785 EXPECT_EQ(0, memcmp("foo", deserialized->random_data.peek_read(), 3));
786 }
787 }
788
TEST(RoundTrip,AbortOperationRequest)789 TEST(RoundTrip, AbortOperationRequest) {
790 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
791 AbortOperationRequest msg(ver);
792 UniquePtr<AbortOperationRequest> deserialized(round_trip(ver, msg, 8));
793 }
794 }
795
TEST(RoundTrip,AttestKeyRequest)796 TEST(RoundTrip, AttestKeyRequest) {
797 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
798 AttestKeyRequest msg(ver);
799 msg.SetKeyMaterial("foo", 3);
800 msg.attest_params.Reinitialize(params, array_length(params));
801
802 UniquePtr<AttestKeyRequest> deserialized(round_trip(ver, msg, 85));
803 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
804 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
805 EXPECT_EQ(msg.attest_params, deserialized->attest_params);
806 }
807 }
808
TEST(RoundTrip,AttestKeyResponse)809 TEST(RoundTrip, AttestKeyResponse) {
810 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
811 AttestKeyResponse msg(ver);
812 msg.error = KM_ERROR_OK;
813 msg.certificate_chain = CertificateChain(3);
814 EXPECT_TRUE(!!msg.certificate_chain.entries);
815 msg.certificate_chain.entries[0] = {dup_buffer("foo", 3), 3};
816 msg.certificate_chain.entries[1] = {dup_buffer("bar", 3), 3};
817 msg.certificate_chain.entries[2] = {dup_buffer("baz", 3), 3};
818
819 UniquePtr<AttestKeyResponse> deserialized(round_trip(ver, msg, 29));
820 keymaster_cert_chain_t* chain = &deserialized->certificate_chain;
821
822 EXPECT_NE(nullptr, chain->entries);
823 EXPECT_EQ(3U, chain->entry_count);
824 EXPECT_EQ(3U, chain->entries[0].data_length);
825 EXPECT_EQ(0, memcmp("foo", chain->entries[0].data, 3));
826 EXPECT_EQ(3U, chain->entries[1].data_length);
827 EXPECT_EQ(0, memcmp("bar", chain->entries[1].data, 3));
828 EXPECT_EQ(3U, chain->entries[2].data_length);
829 EXPECT_EQ(0, memcmp("baz", chain->entries[2].data, 3));
830 }
831 }
832
TEST(RoundTrip,UpgradeKeyRequest)833 TEST(RoundTrip, UpgradeKeyRequest) {
834 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
835 UpgradeKeyRequest msg(ver);
836 msg.SetKeyMaterial("foo", 3);
837 msg.upgrade_params.Reinitialize(params, array_length(params));
838
839 UniquePtr<UpgradeKeyRequest> deserialized(round_trip(ver, msg, 85));
840 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
841 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
842 EXPECT_EQ(msg.upgrade_params, deserialized->upgrade_params);
843 }
844 }
845
TEST(RoundTrip,UpgradeKeyResponse)846 TEST(RoundTrip, UpgradeKeyResponse) {
847 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
848 UpgradeKeyResponse req(ver);
849 req.error = KM_ERROR_OK;
850 req.upgraded_key.key_material = dup_array(TEST_DATA);
851 req.upgraded_key.key_material_size = array_length(TEST_DATA);
852
853 UniquePtr<UpgradeKeyResponse> deserialized(round_trip(ver, req, 19));
854 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
855 EXPECT_EQ(req.upgraded_key.key_material_size, deserialized->upgraded_key.key_material_size);
856 EXPECT_EQ(0, memcmp(req.upgraded_key.key_material, deserialized->upgraded_key.key_material,
857 req.upgraded_key.key_material_size));
858 }
859 }
860
TEST(RoundTrip,GenerateTimestampTokenRequest)861 TEST(RoundTrip, GenerateTimestampTokenRequest) {
862 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
863 GenerateTimestampTokenRequest msg(ver);
864 msg.challenge = 1;
865 UniquePtr<GenerateTimestampTokenRequest> deserialized(round_trip(ver, msg, 8));
866 EXPECT_EQ(1U, deserialized->challenge);
867 }
868 }
869
TEST(RoundTrip,GenerateTimestampTokenResponse)870 TEST(RoundTrip, GenerateTimestampTokenResponse) {
871 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
872 GenerateTimestampTokenResponse msg(ver);
873 msg.error = KM_ERROR_OK;
874 msg.token.challenge = 1;
875 msg.token.timestamp = 2;
876 msg.token.security_level = KM_SECURITY_LEVEL_SOFTWARE;
877 msg.token.mac.data = dup_array(TEST_DATA);
878 msg.token.mac.data_length = array_length(TEST_DATA);
879 UniquePtr<GenerateTimestampTokenResponse> deserialized(round_trip(ver, msg, 39));
880 EXPECT_EQ(1U, deserialized->token.challenge);
881 EXPECT_EQ(2U, deserialized->token.timestamp);
882 EXPECT_EQ(KM_SECURITY_LEVEL_SOFTWARE, deserialized->token.security_level);
883 EXPECT_EQ(msg.token.mac.data_length, deserialized->token.mac.data_length);
884 EXPECT_EQ(
885 0, memcmp(msg.token.mac.data, deserialized->token.mac.data, msg.token.mac.data_length));
886 }
887 }
888
TEST(RoundTrip,GetRootOfTrustRequest)889 TEST(RoundTrip, GetRootOfTrustRequest) {
890 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
891 std::vector<uint8_t> challenge{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
892 GetRootOfTrustRequest msg(ver, challenge);
893
894 UniquePtr<GetRootOfTrustRequest> deserialized(round_trip(ver, msg, 20));
895 EXPECT_EQ(deserialized->challenge, challenge);
896 }
897 }
898
TEST(RoundTrip,GetRootOfTrustResponse)899 TEST(RoundTrip, GetRootOfTrustResponse) {
900 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
901 std::vector<uint8_t> rootOfTrust{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
902 GetRootOfTrustResponse msg(ver, rootOfTrust);
903 msg.error = KM_ERROR_OK;
904
905 UniquePtr<GetRootOfTrustResponse> deserialized(round_trip(ver, msg, 24));
906 EXPECT_EQ(deserialized->rootOfTrust, rootOfTrust);
907 }
908 }
909
TEST(RoundTrip,GetHwInfoResponse)910 TEST(RoundTrip, GetHwInfoResponse) {
911 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
912 GetHwInfoResponse rsp(ver);
913 rsp.error = KM_ERROR_OK;
914 rsp.version = 17;
915 rsp.rpcAuthorName = "AAAAA";
916 rsp.supportedEekCurve = 48;
917 rsp.uniqueId = "BBBBB";
918 rsp.supportedNumKeysInCsr = 549;
919
920 UniquePtr<GetHwInfoResponse> deserialized;
921 deserialized.reset(round_trip(ver, rsp, 34));
922
923 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
924 EXPECT_EQ(deserialized->version, rsp.version);
925 EXPECT_EQ(deserialized->rpcAuthorName, rsp.rpcAuthorName);
926 EXPECT_EQ(deserialized->supportedEekCurve, rsp.supportedEekCurve);
927 EXPECT_EQ(deserialized->uniqueId, rsp.uniqueId);
928 EXPECT_EQ(deserialized->supportedNumKeysInCsr, rsp.supportedNumKeysInCsr);
929 }
930 }
931
932 #define SET_ATTESTATION_ID(x) msg.x.Reinitialize(#x, strlen(#x))
933
check_id(const Buffer & id,const char * value)934 void check_id(const Buffer& id, const char* value) {
935 auto len = strlen(value);
936 EXPECT_EQ(id.available_read(), len) << "On " << value;
937 EXPECT_TRUE(memcmp(id.peek_read(), value, len) == 0) << "On " << value;
938 }
939
940 #define CHECK_ID(x) check_id(deserialized->x, #x);
941
TEST(RoundTrip,SetAttestationIdsRequest)942 TEST(RoundTrip, SetAttestationIdsRequest) {
943 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
944 SetAttestationIdsRequest msg(ver);
945 SET_ATTESTATION_ID(brand);
946 SET_ATTESTATION_ID(device);
947 SET_ATTESTATION_ID(product);
948 SET_ATTESTATION_ID(serial);
949 SET_ATTESTATION_ID(imei);
950 SET_ATTESTATION_ID(meid);
951 SET_ATTESTATION_ID(manufacturer);
952 SET_ATTESTATION_ID(model);
953
954 UniquePtr<SetAttestationIdsRequest> deserialized(round_trip(ver, msg, 81));
955 ASSERT_TRUE(deserialized);
956 CHECK_ID(brand);
957 CHECK_ID(device);
958 CHECK_ID(product);
959 CHECK_ID(serial);
960 CHECK_ID(imei);
961 CHECK_ID(model);
962 }
963 }
964
TEST(RoundTrip,SetAttestationIdsKM3Request)965 TEST(RoundTrip, SetAttestationIdsKM3Request) {
966 for (int ver = 0; ver <= kMaxMessageVersion; ++ver) {
967 SetAttestationIdsKM3Request msg(ver);
968 SET_ATTESTATION_ID(base.brand);
969 SET_ATTESTATION_ID(base.device);
970 SET_ATTESTATION_ID(base.product);
971 SET_ATTESTATION_ID(base.serial);
972 SET_ATTESTATION_ID(base.imei);
973 SET_ATTESTATION_ID(base.meid);
974 SET_ATTESTATION_ID(base.manufacturer);
975 SET_ATTESTATION_ID(base.model);
976 SET_ATTESTATION_ID(second_imei);
977
978 UniquePtr<SetAttestationIdsKM3Request> deserialized(round_trip(ver, msg, 136));
979 ASSERT_TRUE(deserialized);
980 CHECK_ID(base.brand);
981 CHECK_ID(base.device);
982 CHECK_ID(base.product);
983 CHECK_ID(base.serial);
984 CHECK_ID(base.imei);
985 CHECK_ID(base.model);
986 CHECK_ID(second_imei);
987 }
988 }
989
990 uint8_t msgbuf[] = {
991 220, 88, 183, 255, 71, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
992 0, 173, 0, 0, 0, 228, 174, 98, 187, 191, 135, 253, 200, 51, 230, 114, 247, 151, 109,
993 237, 79, 87, 32, 94, 5, 204, 46, 154, 30, 91, 6, 103, 148, 254, 129, 65, 171, 228,
994 167, 224, 163, 9, 15, 206, 90, 58, 11, 205, 55, 211, 33, 87, 178, 149, 91, 28, 236,
995 218, 112, 231, 34, 82, 82, 134, 103, 137, 115, 27, 156, 102, 159, 220, 226, 89, 42, 25,
996 37, 9, 84, 239, 76, 161, 198, 72, 167, 163, 39, 91, 148, 191, 17, 191, 87, 169, 179,
997 136, 10, 194, 154, 4, 40, 107, 109, 61, 161, 20, 176, 247, 13, 214, 106, 229, 45, 17,
998 5, 60, 189, 64, 39, 166, 208, 14, 57, 25, 140, 148, 25, 177, 246, 189, 43, 181, 88,
999 204, 29, 126, 224, 100, 143, 93, 60, 57, 249, 55, 0, 87, 83, 227, 224, 166, 59, 214,
1000 81, 144, 129, 58, 6, 57, 46, 254, 232, 41, 220, 209, 230, 167, 138, 158, 94, 180, 125,
1001 247, 26, 162, 116, 238, 202, 187, 100, 65, 13, 180, 44, 245, 159, 83, 161, 176, 58, 72,
1002 236, 109, 105, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1003 0, 11, 0, 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0,
1004 0, 32, 3, 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0,
1005 1, 0, 0, 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112,
1006 1, 246, 1, 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145,
1007 1, 0, 96, 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0,
1008 0, 0, 0, 0, 190, 2, 0, 16, 1, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
1009 0, 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 0, 11, 0,
1010 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0, 0, 32, 3,
1011 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0, 1, 0, 0,
1012 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112, 1, 246, 1,
1013 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145, 1, 0, 96,
1014 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0, 0, 0, 0,
1015 0, 190, 2, 0, 16, 1, 0, 0, 0,
1016 };
1017
1018 /*
1019 * These tests don't have any assertions or expectations. They just try to parse garbage, to see if
1020 * the result will be a crash. This is especially informative when run under Valgrind memcheck.
1021 */
1022
parse_garbage()1023 template <typename Message> void parse_garbage() {
1024 for (int32_t ver = 0; ver <= kMaxMessageVersion; ++ver) {
1025 Message msg(ver);
1026 const uint8_t* end = msgbuf + array_length(msgbuf);
1027 for (size_t i = 0; i < array_length(msgbuf); ++i) {
1028 const uint8_t* begin = msgbuf + i;
1029 const uint8_t* p = begin;
1030 msg.Deserialize(&p, end);
1031 }
1032 }
1033
1034 time_t now = time(nullptr);
1035 std::cout << "Seeding rand() with " << now << " for fuzz test." << std::endl;
1036 srand(now);
1037
1038 // Fill large buffer with random bytes.
1039 const int kBufSize = 10000;
1040 UniquePtr<uint8_t[]> buf(new uint8_t[kBufSize]);
1041 for (size_t i = 0; i < kBufSize; ++i)
1042 buf[i] = static_cast<uint8_t>(rand());
1043
1044 for (uint32_t ver = 0; ver < kMaxMessageVersion; ++ver) {
1045 Message msg(ver);
1046 const uint8_t* end = buf.get() + kBufSize;
1047 for (size_t i = 0; i < kBufSize; ++i) {
1048 const uint8_t* begin = buf.get() + i;
1049 const uint8_t* p = begin;
1050 msg.Deserialize(&p, end);
1051 }
1052 }
1053 }
1054
1055 #define GARBAGE_TEST(Message) \
1056 TEST(GarbageTest, Message) { \
1057 parse_garbage<Message>(); \
1058 }
1059
1060 GARBAGE_TEST(AbortOperationRequest);
1061 GARBAGE_TEST(EmptyKeymasterResponse);
1062 GARBAGE_TEST(AddEntropyRequest);
1063 GARBAGE_TEST(BeginOperationRequest);
1064 GARBAGE_TEST(BeginOperationResponse);
1065 GARBAGE_TEST(DeleteAllKeysRequest);
1066 GARBAGE_TEST(DeleteKeyRequest);
1067 GARBAGE_TEST(ExportKeyRequest);
1068 GARBAGE_TEST(ExportKeyResponse);
1069 GARBAGE_TEST(FinishOperationRequest);
1070 GARBAGE_TEST(FinishOperationResponse);
1071 GARBAGE_TEST(GenerateKeyRequest);
1072 GARBAGE_TEST(GenerateKeyResponse);
1073 GARBAGE_TEST(GetKeyCharacteristicsRequest);
1074 GARBAGE_TEST(GetKeyCharacteristicsResponse);
1075 GARBAGE_TEST(ImportKeyRequest);
1076 GARBAGE_TEST(ImportKeyResponse);
1077 GARBAGE_TEST(UpdateOperationRequest);
1078 GARBAGE_TEST(UpdateOperationResponse);
1079 GARBAGE_TEST(AttestKeyRequest);
1080 GARBAGE_TEST(AttestKeyResponse);
1081 GARBAGE_TEST(UpgradeKeyRequest);
1082 GARBAGE_TEST(UpgradeKeyResponse);
1083 GARBAGE_TEST(GenerateTimestampTokenRequest);
1084 GARBAGE_TEST(GenerateTimestampTokenResponse);
1085 GARBAGE_TEST(SetAttestationIdsRequest);
1086 GARBAGE_TEST(SetAttestationIdsKM3Request);
1087 GARBAGE_TEST(ConfigureVerifiedBootInfoRequest);
1088 GARBAGE_TEST(GetRootOfTrustRequest);
1089 GARBAGE_TEST(GetRootOfTrustResponse);
1090
1091 } // namespace test
1092
1093 } // namespace keymaster
1094