blob: aa0f57169344b9f6faf1795ae29f29bf07015d5a [file] [log] [blame]
Shawn Willden128ffe02014-08-06 12:31:33 -06001/*
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 <UniquePtr.h>
18
19#include <gtest/gtest.h>
20
Shawn Willden98d9b922014-08-26 08:14:10 -060021#include <keymaster/keymaster_tags.h>
22#include <keymaster/google_keymaster_utils.h>
23
Shawn Willdenda8485e2014-08-17 08:00:01 -060024#include "google_keymaster_test_utils.h"
Shawn Willden128ffe02014-08-06 12:31:33 -060025#include "google_softkeymaster.h"
26
27int main(int argc, char** argv) {
28 ::testing::InitGoogleTest(&argc, argv);
29 int result = RUN_ALL_TESTS();
30 return result;
31}
32
33namespace keymaster {
34namespace test {
35
Shawn Willdenda8485e2014-08-17 08:00:01 -060036/**
37 * Serialize and deserialize a message.
38 */
Shawn Willden2665e862014-11-24 14:46:21 -070039template <typename Message>
40Message* round_trip(int32_t ver, const Message& message, size_t expected_size) {
Shawn Willdenda8485e2014-08-17 08:00:01 -060041 size_t size = message.SerializedSize();
42 EXPECT_EQ(expected_size, size);
43 if (size == 0)
44 return NULL;
Shawn Willden128ffe02014-08-06 12:31:33 -060045
46 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
Shawn Willdenda8485e2014-08-17 08:00:01 -060047 EXPECT_EQ(buf.get() + size, message.Serialize(buf.get(), buf.get() + size));
Shawn Willden128ffe02014-08-06 12:31:33 -060048
Shawn Willden2665e862014-11-24 14:46:21 -070049 Message* deserialized = new Message(ver);
Shawn Willden58e1a542014-08-08 21:58:29 -060050 const uint8_t* p = buf.get();
Shawn Willdenda8485e2014-08-17 08:00:01 -060051 EXPECT_TRUE(deserialized->Deserialize(&p, p + size));
52 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
53 return deserialized;
Shawn Willden128ffe02014-08-06 12:31:33 -060054}
55
Shawn Willden2665e862014-11-24 14:46:21 -070056struct EmptyKeymasterResponse : public KeymasterResponse {
57 EmptyKeymasterResponse(int32_t ver) : KeymasterResponse(ver) {}
Shawn Willdenda8485e2014-08-17 08:00:01 -060058 size_t NonErrorSerializedSize() const { return 1; }
59 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* /* end */) const {
60 *buf++ = 0;
61 return buf;
62 }
63 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) {
64 if (*buf_ptr >= end)
65 return false;
66 EXPECT_EQ(0, **buf_ptr);
67 (*buf_ptr)++;
68 return true;
69 }
70};
71
72TEST(RoundTrip, EmptyKeymasterResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -070073 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
74 EmptyKeymasterResponse msg(ver);
75 msg.error = KM_ERROR_OK;
Shawn Willdenda8485e2014-08-17 08:00:01 -060076
Shawn Willden2665e862014-11-24 14:46:21 -070077 UniquePtr<EmptyKeymasterResponse> deserialized(round_trip(ver, msg, 5));
78 }
Shawn Willdenda8485e2014-08-17 08:00:01 -060079}
80
81TEST(RoundTrip, EmptyKeymasterResponseError) {
Shawn Willden2665e862014-11-24 14:46:21 -070082 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
83 EmptyKeymasterResponse msg(ver);
84 msg.error = KM_ERROR_MEMORY_ALLOCATION_FAILED;
Shawn Willdenda8485e2014-08-17 08:00:01 -060085
Shawn Willden2665e862014-11-24 14:46:21 -070086 UniquePtr<EmptyKeymasterResponse> deserialized(round_trip(ver, msg, 4));
87 }
Shawn Willdenda8485e2014-08-17 08:00:01 -060088}
89
90TEST(RoundTrip, SupportedAlgorithmsResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -070091 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
92 SupportedAlgorithmsResponse rsp(ver);
93 keymaster_algorithm_t algorithms[] = {KM_ALGORITHM_RSA, KM_ALGORITHM_DSA,
94 KM_ALGORITHM_ECDSA};
95 rsp.error = KM_ERROR_OK;
96 rsp.algorithms = dup_array(algorithms);
97 rsp.algorithms_length = array_length(algorithms);
Shawn Willdenda8485e2014-08-17 08:00:01 -060098
Shawn Willden2665e862014-11-24 14:46:21 -070099 UniquePtr<SupportedAlgorithmsResponse> deserialized(round_trip(ver, rsp, 20));
100 EXPECT_EQ(array_length(algorithms), deserialized->algorithms_length);
101 EXPECT_EQ(0, memcmp(deserialized->algorithms, algorithms, array_size(algorithms)));
102 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600103}
104
105TEST(RoundTrip, SupportedResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700106 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
107 SupportedResponse<keymaster_digest_t> rsp(ver);
108 keymaster_digest_t digests[] = {KM_DIGEST_NONE, KM_DIGEST_MD5, KM_DIGEST_SHA1};
109 rsp.error = KM_ERROR_OK;
110 rsp.SetResults(digests);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600111
Shawn Willden2665e862014-11-24 14:46:21 -0700112 UniquePtr<SupportedResponse<keymaster_digest_t>> deserialized(round_trip(ver, rsp, 20));
113 EXPECT_EQ(array_length(digests), deserialized->results_length);
114 EXPECT_EQ(0, memcmp(deserialized->results, digests, array_size(digests)));
115 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600116}
117
118static keymaster_key_param_t params[] = {
Shawn Willden2665e862014-11-24 14:46:21 -0700119 Authorization(TAG_PURPOSE, KM_PURPOSE_SIGN), Authorization(TAG_PURPOSE, KM_PURPOSE_VERIFY),
Shawn Willdenda8485e2014-08-17 08:00:01 -0600120 Authorization(TAG_ALGORITHM, KM_ALGORITHM_RSA), Authorization(TAG_USER_ID, 7),
Shawn Willden2665e862014-11-24 14:46:21 -0700121 Authorization(TAG_USER_AUTH_ID, 8), Authorization(TAG_APPLICATION_ID, "app_id", 6),
Shawn Willdenda8485e2014-08-17 08:00:01 -0600122 Authorization(TAG_AUTH_TIMEOUT, 300),
123};
Shawn Willden128ffe02014-08-06 12:31:33 -0600124uint8_t TEST_DATA[] = "a key blob";
125
Shawn Willdenda8485e2014-08-17 08:00:01 -0600126TEST(RoundTrip, GenerateKeyRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700127 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
128 GenerateKeyRequest req(ver);
129 req.key_description.Reinitialize(params, array_length(params));
130 UniquePtr<GenerateKeyRequest> deserialized(round_trip(ver, req, 78));
131 EXPECT_EQ(deserialized->key_description, req.key_description);
132 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600133}
134
135TEST(RoundTrip, GenerateKeyResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700136 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
137 GenerateKeyResponse rsp(ver);
138 rsp.error = KM_ERROR_OK;
139 rsp.key_blob.key_material = dup_array(TEST_DATA);
140 rsp.key_blob.key_material_size = array_length(TEST_DATA);
141 rsp.enforced.Reinitialize(params, array_length(params));
Shawn Willden128ffe02014-08-06 12:31:33 -0600142
Shawn Willden2665e862014-11-24 14:46:21 -0700143 UniquePtr<GenerateKeyResponse> deserialized(round_trip(ver, rsp, 109));
144 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
145 EXPECT_EQ(deserialized->enforced, rsp.enforced);
146 EXPECT_EQ(deserialized->unenforced, rsp.unenforced);
147 }
Shawn Willden128ffe02014-08-06 12:31:33 -0600148}
149
Shawn Willdenda8485e2014-08-17 08:00:01 -0600150TEST(RoundTrip, GenerateKeyResponseTestError) {
Shawn Willden2665e862014-11-24 14:46:21 -0700151 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
152 GenerateKeyResponse rsp(ver);
153 rsp.error = KM_ERROR_UNSUPPORTED_ALGORITHM;
154 rsp.key_blob.key_material = dup_array(TEST_DATA);
155 rsp.key_blob.key_material_size = array_length(TEST_DATA);
156 rsp.enforced.Reinitialize(params, array_length(params));
Shawn Willden128ffe02014-08-06 12:31:33 -0600157
Shawn Willden2665e862014-11-24 14:46:21 -0700158 UniquePtr<GenerateKeyResponse> deserialized(round_trip(ver, rsp, 4));
159 EXPECT_EQ(KM_ERROR_UNSUPPORTED_ALGORITHM, deserialized->error);
160 EXPECT_EQ(0U, deserialized->enforced.size());
161 EXPECT_EQ(0U, deserialized->unenforced.size());
162 EXPECT_EQ(0U, deserialized->key_blob.key_material_size);
163 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600164}
Shawn Willden128ffe02014-08-06 12:31:33 -0600165
Shawn Willdenda8485e2014-08-17 08:00:01 -0600166TEST(RoundTrip, GetKeyCharacteristicsRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700167 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
168 GetKeyCharacteristicsRequest req(ver);
169 req.additional_params.Reinitialize(params, array_length(params));
170 req.SetKeyMaterial("foo", 3);
Shawn Willden128ffe02014-08-06 12:31:33 -0600171
Shawn Willden2665e862014-11-24 14:46:21 -0700172 UniquePtr<GetKeyCharacteristicsRequest> deserialized(round_trip(ver, req, 85));
173 EXPECT_EQ(7U, deserialized->additional_params.size());
174 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
175 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
176 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600177}
178
179TEST(RoundTrip, GetKeyCharacteristicsResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700180 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
181 GetKeyCharacteristicsResponse msg(ver);
182 msg.error = KM_ERROR_OK;
183 msg.enforced.Reinitialize(params, array_length(params));
184 msg.unenforced.Reinitialize(params, array_length(params));
Shawn Willdenda8485e2014-08-17 08:00:01 -0600185
Shawn Willden2665e862014-11-24 14:46:21 -0700186 UniquePtr<GetKeyCharacteristicsResponse> deserialized(round_trip(ver, msg, 160));
187 EXPECT_EQ(msg.enforced, deserialized->enforced);
188 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
189 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600190}
191
192TEST(RoundTrip, BeginOperationRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700193 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
194 BeginOperationRequest msg(ver);
195 msg.purpose = KM_PURPOSE_SIGN;
196 msg.SetKeyMaterial("foo", 3);
197 msg.additional_params.Reinitialize(params, array_length(params));
Shawn Willdenda8485e2014-08-17 08:00:01 -0600198
Shawn Willden2665e862014-11-24 14:46:21 -0700199 UniquePtr<BeginOperationRequest> deserialized(round_trip(ver, msg, 89));
200 EXPECT_EQ(KM_PURPOSE_SIGN, deserialized->purpose);
201 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
202 EXPECT_EQ(0, memcmp(deserialized->key_blob.key_material, "foo", 3));
203 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
204 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600205}
206
207TEST(RoundTrip, BeginOperationResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700208 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
209 BeginOperationResponse msg(ver);
210 msg.error = KM_ERROR_OK;
211 msg.op_handle = 0xDEADBEEF;
Shawn Willden7b38f442015-01-22 13:07:34 -0700212 msg.output_params.push_back(Authorization(TAG_NONCE, "foo", 3));
Shawn Willdenda8485e2014-08-17 08:00:01 -0600213
Shawn Willden7b38f442015-01-22 13:07:34 -0700214 UniquePtr<BeginOperationResponse> deserialized;
215 switch (ver) {
216 case 0:
217 deserialized.reset(round_trip(ver, msg, 12));
218 break;
219 case 1:
220 deserialized.reset(round_trip(ver, msg, 39));
221 break;
222 default:
223 FAIL();
224 }
225
Shawn Willden2665e862014-11-24 14:46:21 -0700226 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
227 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
Shawn Willden7b38f442015-01-22 13:07:34 -0700228
229 switch (ver) {
230 case 0:
231 EXPECT_EQ(0, deserialized->output_params.size());
232 break;
233 case 1:
234 EXPECT_EQ(msg.output_params, deserialized->output_params);
235 break;
236 default:
237 FAIL();
238 }
Shawn Willden2665e862014-11-24 14:46:21 -0700239 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600240}
241
242TEST(RoundTrip, BeginOperationResponseError) {
Shawn Willden2665e862014-11-24 14:46:21 -0700243 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
244 BeginOperationResponse msg(ver);
245 msg.error = KM_ERROR_INVALID_OPERATION_HANDLE;
246 msg.op_handle = 0xDEADBEEF;
Shawn Willdenda8485e2014-08-17 08:00:01 -0600247
Shawn Willden2665e862014-11-24 14:46:21 -0700248 UniquePtr<BeginOperationResponse> deserialized(round_trip(ver, msg, 4));
249 EXPECT_EQ(KM_ERROR_INVALID_OPERATION_HANDLE, deserialized->error);
250 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600251}
252
253TEST(RoundTrip, UpdateOperationRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700254 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
255 UpdateOperationRequest msg(ver);
256 msg.op_handle = 0xDEADBEEF;
257 msg.input.Reinitialize("foo", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600258
Shawn Willdenba5e94d2015-02-06 17:09:23 -0700259 UniquePtr<UpdateOperationRequest> deserialized;
260 switch(ver) {
261 case 0:
262 deserialized.reset(round_trip(ver, msg, 15));
263 break;
264 case 1:
265 deserialized.reset(round_trip(ver, msg, 27));
266 break;
267 default:
268 FAIL();
269 }
Shawn Willden2665e862014-11-24 14:46:21 -0700270 EXPECT_EQ(3U, deserialized->input.available_read());
271 EXPECT_EQ(0, memcmp(deserialized->input.peek_read(), "foo", 3));
272 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600273}
274
275TEST(RoundTrip, UpdateOperationResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700276 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
277 UpdateOperationResponse msg(ver);
278 msg.error = KM_ERROR_OK;
279 msg.output.Reinitialize("foo", 3);
Shawn Willdenb7361132014-12-08 08:15:14 -0700280 msg.input_consumed = 99;
Shawn Willdenda8485e2014-08-17 08:00:01 -0600281
Shawn Willdenb7361132014-12-08 08:15:14 -0700282 UniquePtr<UpdateOperationResponse> deserialized;
283 switch (ver) {
284 case 0:
285 deserialized.reset(round_trip(ver, msg, 11));
286 break;
287 case 1:
288 deserialized.reset(round_trip(ver, msg, 15));
289 break;
290 default:
291 FAIL();
292 }
Shawn Willden2665e862014-11-24 14:46:21 -0700293 EXPECT_EQ(KM_ERROR_OK, deserialized->error);
294 EXPECT_EQ(3U, deserialized->output.available_read());
295 EXPECT_EQ(0, memcmp(deserialized->output.peek_read(), "foo", 3));
Shawn Willdenb7361132014-12-08 08:15:14 -0700296
297 switch (ver) {
298 case 0:
299 EXPECT_EQ(0, deserialized->input_consumed);
300 break;
301 case 1:
302 EXPECT_EQ(99, deserialized->input_consumed);
303 break;
304 default:
305 FAIL();
306 }
Shawn Willden2665e862014-11-24 14:46:21 -0700307 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600308}
309
310TEST(RoundTrip, FinishOperationRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700311 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
312 FinishOperationRequest msg(ver);
313 msg.op_handle = 0xDEADBEEF;
314 msg.signature.Reinitialize("bar", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600315
Shawn Willdenba5e94d2015-02-06 17:09:23 -0700316 UniquePtr<FinishOperationRequest> deserialized;
317 switch(ver) {
318 case 0:
319 deserialized.reset(round_trip(ver, msg, 15));
320 break;
321 case 1:
322 deserialized.reset(round_trip(ver, msg, 27));
323 break;
324 default:
325 FAIL();
326 }
Shawn Willden2665e862014-11-24 14:46:21 -0700327 EXPECT_EQ(0xDEADBEEF, deserialized->op_handle);
328 EXPECT_EQ(3U, deserialized->signature.available_read());
329 EXPECT_EQ(0, memcmp(deserialized->signature.peek_read(), "bar", 3));
330 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600331}
332
333TEST(Round_Trip, FinishOperationResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700334 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
335 FinishOperationResponse msg(ver);
336 msg.error = KM_ERROR_OK;
337 msg.output.Reinitialize("foo", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600338
Shawn Willden2665e862014-11-24 14:46:21 -0700339 UniquePtr<FinishOperationResponse> deserialized(round_trip(ver, msg, 11));
340 EXPECT_EQ(msg.error, deserialized->error);
341 EXPECT_EQ(msg.output.available_read(), deserialized->output.available_read());
342 EXPECT_EQ(0, memcmp(msg.output.peek_read(), deserialized->output.peek_read(),
343 msg.output.available_read()));
344 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600345}
346
347TEST(RoundTrip, ImportKeyRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700348 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
349 ImportKeyRequest msg(ver);
350 msg.key_description.Reinitialize(params, array_length(params));
351 msg.key_format = KM_KEY_FORMAT_X509;
352 msg.SetKeyMaterial("foo", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600353
Shawn Willden2665e862014-11-24 14:46:21 -0700354 UniquePtr<ImportKeyRequest> deserialized(round_trip(ver, msg, 89));
355 EXPECT_EQ(msg.key_description, deserialized->key_description);
356 EXPECT_EQ(msg.key_format, deserialized->key_format);
357 EXPECT_EQ(msg.key_data_length, deserialized->key_data_length);
358 EXPECT_EQ(0, memcmp(msg.key_data, deserialized->key_data, msg.key_data_length));
359 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600360}
361
362TEST(RoundTrip, ImportKeyResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700363 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
364 ImportKeyResponse msg(ver);
365 msg.error = KM_ERROR_OK;
366 msg.SetKeyMaterial("foo", 3);
367 msg.enforced.Reinitialize(params, array_length(params));
368 msg.unenforced.Reinitialize(params, array_length(params));
Shawn Willdenda8485e2014-08-17 08:00:01 -0600369
Shawn Willden2665e862014-11-24 14:46:21 -0700370 UniquePtr<ImportKeyResponse> deserialized(round_trip(ver, msg, 167));
371 EXPECT_EQ(msg.error, deserialized->error);
372 EXPECT_EQ(msg.key_blob.key_material_size, deserialized->key_blob.key_material_size);
373 EXPECT_EQ(0, memcmp(msg.key_blob.key_material, deserialized->key_blob.key_material,
374 msg.key_blob.key_material_size));
375 EXPECT_EQ(msg.enforced, deserialized->enforced);
376 EXPECT_EQ(msg.unenforced, deserialized->unenforced);
377 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600378}
379
380TEST(RoundTrip, ExportKeyRequest) {
Shawn Willden2665e862014-11-24 14:46:21 -0700381 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
382 ExportKeyRequest msg(ver);
383 msg.additional_params.Reinitialize(params, array_length(params));
384 msg.key_format = KM_KEY_FORMAT_X509;
385 msg.SetKeyMaterial("foo", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600386
Shawn Willden2665e862014-11-24 14:46:21 -0700387 UniquePtr<ExportKeyRequest> deserialized(round_trip(ver, msg, 89));
388 EXPECT_EQ(msg.additional_params, deserialized->additional_params);
389 EXPECT_EQ(msg.key_format, deserialized->key_format);
390 EXPECT_EQ(3U, deserialized->key_blob.key_material_size);
391 EXPECT_EQ(0, memcmp("foo", deserialized->key_blob.key_material, 3));
392 }
Shawn Willdenda8485e2014-08-17 08:00:01 -0600393}
394
395TEST(RoundTrip, ExportKeyResponse) {
Shawn Willden2665e862014-11-24 14:46:21 -0700396 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
397 ExportKeyResponse msg(ver);
398 msg.error = KM_ERROR_OK;
399 msg.SetKeyMaterial("foo", 3);
Shawn Willdenda8485e2014-08-17 08:00:01 -0600400
Shawn Willden2665e862014-11-24 14:46:21 -0700401 UniquePtr<ExportKeyResponse> deserialized(round_trip(ver, msg, 11));
402 EXPECT_EQ(3U, deserialized->key_data_length);
403 EXPECT_EQ(0, memcmp("foo", deserialized->key_data, 3));
404 }
405}
406
407TEST(RoundTrip, GetVersionRequest) {
408 GetVersionRequest msg;
409
410 size_t size = msg.SerializedSize();
411 ASSERT_EQ(0, size);
412
413 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
414 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
415
416 GetVersionRequest deserialized;
417 const uint8_t* p = buf.get();
418 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
419 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
420}
421
422TEST(RoundTrip, GetVersionResponse) {
423 GetVersionResponse msg;
424 msg.error = KM_ERROR_OK;
425 msg.major_ver = 9;
426 msg.minor_ver = 98;
427 msg.subminor_ver = 38;
428
429 size_t size = msg.SerializedSize();
430 ASSERT_EQ(7, size);
431
432 UniquePtr<uint8_t[]> buf(new uint8_t[size]);
433 EXPECT_EQ(buf.get() + size, msg.Serialize(buf.get(), buf.get() + size));
434
435 GetVersionResponse deserialized;
436 const uint8_t* p = buf.get();
437 EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
438 EXPECT_EQ((ptrdiff_t)size, p - buf.get());
439 EXPECT_EQ(9, msg.major_ver);
440 EXPECT_EQ(98, msg.minor_ver);
441 EXPECT_EQ(38, msg.subminor_ver);
Shawn Willden128ffe02014-08-06 12:31:33 -0600442}
443
Shawn Willdencd695822015-01-26 14:06:32 -0700444TEST(RoundTrip, AddEntropyRequest) {
445 for (int ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
446 AddEntropyRequest msg(ver);
447 msg.random_data.Reinitialize("foo", 3);
448
449 UniquePtr<AddEntropyRequest> deserialized(round_trip(ver, msg, 7));
450 EXPECT_EQ(3U, deserialized->random_data.available_read());
451 EXPECT_EQ(0, memcmp("foo", deserialized->random_data.peek_read(), 3));
452 }
453}
454
Shawn Willdenf2282b32014-08-25 06:49:54 -0600455uint8_t msgbuf[] = {
456 220, 88, 183, 255, 71, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
457 0, 173, 0, 0, 0, 228, 174, 98, 187, 191, 135, 253, 200, 51, 230, 114, 247, 151, 109,
458 237, 79, 87, 32, 94, 5, 204, 46, 154, 30, 91, 6, 103, 148, 254, 129, 65, 171, 228,
459 167, 224, 163, 9, 15, 206, 90, 58, 11, 205, 55, 211, 33, 87, 178, 149, 91, 28, 236,
460 218, 112, 231, 34, 82, 82, 134, 103, 137, 115, 27, 156, 102, 159, 220, 226, 89, 42, 25,
461 37, 9, 84, 239, 76, 161, 198, 72, 167, 163, 39, 91, 148, 191, 17, 191, 87, 169, 179,
462 136, 10, 194, 154, 4, 40, 107, 109, 61, 161, 20, 176, 247, 13, 214, 106, 229, 45, 17,
463 5, 60, 189, 64, 39, 166, 208, 14, 57, 25, 140, 148, 25, 177, 246, 189, 43, 181, 88,
464 204, 29, 126, 224, 100, 143, 93, 60, 57, 249, 55, 0, 87, 83, 227, 224, 166, 59, 214,
465 81, 144, 129, 58, 6, 57, 46, 254, 232, 41, 220, 209, 230, 167, 138, 158, 94, 180, 125,
466 247, 26, 162, 116, 238, 202, 187, 100, 65, 13, 180, 44, 245, 159, 83, 161, 176, 58, 72,
467 236, 109, 105, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
468 0, 11, 0, 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0,
469 0, 32, 3, 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0,
470 1, 0, 0, 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112,
471 1, 246, 1, 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145,
472 1, 0, 96, 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0,
473 0, 0, 0, 0, 190, 2, 0, 16, 1, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
474 0, 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 0, 11, 0,
475 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0, 0, 32, 3,
476 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0, 1, 0, 0,
477 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112, 1, 246, 1,
478 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145, 1, 0, 96,
479 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0, 0, 0, 0,
480 0, 190, 2, 0, 16, 1, 0, 0, 0,
481};
482
483/*
484 * These tests don't have any assertions or expectations. They just try to parse garbage, to see if
485 * the result will be a crash. This is especially informative when run under Valgrind memcheck.
486 */
487
488template <typename Message> void parse_garbage() {
Shawn Willden2665e862014-11-24 14:46:21 -0700489 for (int32_t ver = 0; ver <= MAX_MESSAGE_VERSION; ++ver) {
490 Message msg(ver);
491 const uint8_t* end = msgbuf + array_length(msgbuf);
492 for (size_t i = 0; i < array_length(msgbuf); ++i) {
493 const uint8_t* begin = msgbuf + i;
494 const uint8_t* p = begin;
495 msg.Deserialize(&p, end);
496 }
Shawn Willdenf2282b32014-08-25 06:49:54 -0600497 }
498}
499
500#define GARBAGE_TEST(Message) \
501 TEST(GarbageTest, Message) { parse_garbage<Message>(); }
502
503GARBAGE_TEST(SupportedAlgorithmsResponse)
504GARBAGE_TEST(GenerateKeyRequest);
505GARBAGE_TEST(GenerateKeyResponse);
506GARBAGE_TEST(GetKeyCharacteristicsRequest);
507GARBAGE_TEST(GetKeyCharacteristicsResponse);
508GARBAGE_TEST(BeginOperationRequest);
509GARBAGE_TEST(BeginOperationResponse);
510GARBAGE_TEST(UpdateOperationRequest);
511GARBAGE_TEST(UpdateOperationResponse);
512GARBAGE_TEST(FinishOperationRequest);
513GARBAGE_TEST(FinishOperationResponse);
Shawn Willdencd695822015-01-26 14:06:32 -0700514GARBAGE_TEST(AddEntropyRequest);
Shawn Willdenf2282b32014-08-25 06:49:54 -0600515GARBAGE_TEST(ImportKeyRequest);
516GARBAGE_TEST(ImportKeyResponse);
517GARBAGE_TEST(ExportKeyRequest);
518GARBAGE_TEST(ExportKeyResponse);
519// GARBAGE_TEST(RescopeRequest);
520// GARBAGE_TEST(RescopeResponse);
521
522// The macro doesn't work on this one.
523TEST(GarbageTest, SupportedResponse) {
524 parse_garbage<SupportedResponse<keymaster_digest_t>>();
525}
526
Shawn Willden128ffe02014-08-06 12:31:33 -0600527} // namespace test
Shawn Willden2665e862014-11-24 14:46:21 -0700528
Shawn Willden128ffe02014-08-06 12:31:33 -0600529} // namespace keymaster