1 /*
2 * Copyright (c) 2020-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdint>
17 #include <cstdlib>
18 #include "gtest/gtest.h"
19 #include "gmock/gmock.h"
20 #include "securec.h"
21 #include "hichain.h"
22 #include "distribution.h"
23 #include "cJSON.h"
24 #include "huks_adapter_test.h"
25 #include "auth_info_test.h"
26
27 #define LOG(format, ...) (printf(format"\n", ##__VA_ARGS__))
28
29 using namespace std;
30 using namespace testing::ext;
31
32
33 namespace {
34 const int KEY_LEN = 16;
35 const int AUTH_ID_LENGTH = 64;
36 const int ERROR_ZERO_LENGTH = 0;
37 const int ERROR_LENGTH = 258;
38
39 int32_t GenerateSignMessage(hc_handle handle, struct uint8_buff *message);
40
41 static struct session_identity g_server_identity = {
42 153666603,
43 {strlen("aaa.bbbb.ccc"), "aaa.bbbb.ccc"},
44 {strlen("CarDevice"), "CarDevice"},
45 0
46 };
47
48 static struct session_identity g_server_identity_001 = {
49 153666603,
50 {ERROR_LENGTH, "aaa.bbbb.ccc"},
51 {strlen("CarDevice"), "CarDevice"},
52 0
53 };
54
55 static struct session_identity g_server_identity_002 = {
56 153666603,
57 {strlen("aaa.bbbb.ccc"), "aaa.bbbb.ccc"},
58 {ERROR_LENGTH, "CarDevice"},
59 0
60 };
61
62 static struct session_identity g_server_identity_003 = {
63 153666603,
64 {ERROR_ZERO_LENGTH, "aaa.bbbb.ccc"},
65 {ERROR_LENGTH, "CarDevice"},
66 0
67 };
68
69 static struct session_identity g_server_identity_004 = {
70 153666603,
71 {HC_PACKAGE_NAME_BUFF_LEN, ""},
72 {HC_SERVICE_TYPE_BUFF_LEN, "CarDevice"},
73 0
74 };
75
76 static struct session_identity g_server_identity_005 = {
77 153666603,
78 {strlen("aaa.bbbb.ccc"), "aaa.bbbb.ccc"},
79 {HC_SERVICE_TYPE_BUFF_LEN, ""},
80 0
81 };
82
83 static struct hc_pin g_test_pin = {strlen("123456"), "123456"};
84 static struct hc_auth_id g_test_client_auth_id;
85 static struct hc_auth_id g_test_server_auth_id;
86 static int32_t g_result;
87
88 uint8_t g_testPhoneId[65] = {"14bb6543b893a3250f5793fbbbd48be56641505dc6514be1bb37b032903ebc67"};
89 uint8_t g_testCarId[65] = {"d37cd7ceb894f4393a299ef852b4fc35a1a0d77c48a5b3e0b2599ab1d69b23a6"};
90
InitHcAuthId()91 void InitHcAuthId()
92 {
93 memcpy_s(g_test_client_auth_id.auth_id, AUTH_ID_LENGTH, g_testPhoneId, AUTH_ID_LENGTH);
94 g_test_client_auth_id.length = AUTH_ID_LENGTH;
95
96 memcpy_s(g_test_server_auth_id.auth_id, AUTH_ID_LENGTH, g_testCarId, AUTH_ID_LENGTH);
97 g_test_server_auth_id.length = AUTH_ID_LENGTH;
98 return ;
99 }
100
Transmit(const struct session_identity * identity,const void * data,uint32_t length)101 static void Transmit(const struct session_identity *identity, const void *data, uint32_t length)
102 {
103 LOG("--------Transmit--------");
104 LOG("identity session_id[%d] package_name[%s]", identity->session_id, identity->package_name.name);
105 LOG("length[%u]", length);
106 LOG("--------Transmit--------");
107 }
108
GetProtocolParams(const struct session_identity * identity,int32_t operationCode,struct hc_pin * pin,struct operation_parameter * para)109 static void GetProtocolParams(const struct session_identity *identity, int32_t operationCode,
110 struct hc_pin *pin, struct operation_parameter *para)
111 {
112 LOG("--------GetProtocolParams--------");
113 LOG("identity session_id[%d] package_name[%s]", identity->session_id, identity->package_name.name);
114 LOG("operationCode[%d]", operationCode);
115 pin->length = g_test_pin.length;
116 memcpy_s(pin->pin, pin->length, g_test_pin.pin, pin->length);
117 para->self_auth_id = g_test_server_auth_id;
118 para->peer_auth_id = g_test_client_auth_id;
119 para->key_length = KEY_LEN;
120 LOG("--------GetProtocolParams--------");
121 }
122
SetSessionKey(const struct session_identity * identity,const struct hc_session_key * sessionKey)123 static void SetSessionKey(const struct session_identity *identity, const struct hc_session_key *sessionKey)
124 {
125 LOG("--------SetSessionKey--------");
126 LOG("identity session_id[%d] package_name[%s]", identity->session_id, identity->package_name.name);
127 LOG("sessionKey[%s]", sessionKey->session_key);
128 LOG("--------SetSessionKey--------");
129 }
130
SetServiceResult(const struct session_identity * identity,int32_t result,int32_t errorCode)131 static void SetServiceResult(const struct session_identity *identity, int32_t result, int32_t errorCode)
132 {
133 LOG("--------SetServiceResult--------");
134 LOG("identity session_id[%d] package_name[%s]", identity->session_id, identity->package_name.name);
135 LOG("result[%d]", result);
136 LOG("--------SetServiceResult--------");
137 g_result = result;
138 }
139
ConfirmReceiveRequest(const struct session_identity * identity,int32_t operationCode)140 static int32_t ConfirmReceiveRequest(const struct session_identity *identity, int32_t operationCode)
141 {
142 LOG("--------ConfirmReceiveRequest--------");
143 LOG("identity session_id[%d] package_name[%s]", identity->session_id, identity->package_name.name);
144 LOG("operationCode[%d]", operationCode);
145 LOG("--------ConfirmReceiveRequest--------");
146 return HC_OK;
147 }
148
149 class HuksAdapterTest : public testing::Test {
150 public:
151 static void SetUpTestCase(void);
152 static void TearDownTestCase(void);
153 void SetUp();
154 void TearDown();
155 };
156
SetUpTestCase(void)157 void HuksAdapterTest::SetUpTestCase(void) {}
TearDownTestCase(void)158 void HuksAdapterTest::TearDownTestCase(void) {}
SetUp()159 void HuksAdapterTest::SetUp()
160 {
161 InitHcAuthId();
162 }
TearDown()163 void HuksAdapterTest::TearDown() {}
164
165 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest001, TestSize.Level2)
166 {
167 LOG("--------HuksAdapterTest Test001--------");
168 LOG("--------generate_service_id--------");
169 struct service_id service_id = generate_service_id(&g_server_identity);
170 EXPECT_GT(service_id.length, 0);
171 LOG("--------HuksAdapterTest Test001--------");
172 }
173
174 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest002, TestSize.Level2)
175 {
176 LOG("--------HuksAdapterTest Test002--------");
177 LOG("--------generate_service_id--------");
178 struct service_id service_id = generate_service_id(&g_server_identity_001);
179 EXPECT_EQ(service_id.length, 0);
180 LOG("--------HuksAdapterTest Test002--------");
181 }
182
183 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest003, TestSize.Level2)
184 {
185 LOG("--------HuksAdapterTest Test003--------");
186 LOG("--------generate_service_id--------");
187 struct service_id service_id = generate_service_id(&g_server_identity_002);
188 EXPECT_EQ(service_id.length, 0);
189 LOG("--------HuksAdapterTest Test003--------");
190 }
191
192 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest004, TestSize.Level2)
193 {
194 LOG("--------HuksAdapterTest Test004--------");
195 LOG("--------generate_service_id--------");
196 struct service_id service_id = generate_service_id(&g_server_identity_003);
197 EXPECT_EQ(service_id.length, 0);
198 LOG("--------HuksAdapterTest Test004--------");
199 }
200
201 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest005, TestSize.Level2)
202 {
203 LOG("--------HuksAdapterTest Test005--------");
204 LOG("--------generate_service_id--------");
205 struct session_identity *identity = nullptr;
206 struct service_id service_id = generate_service_id(identity);
207 EXPECT_EQ(service_id.length, 0);
208 LOG("--------HuksAdapterTest Test005--------");
209 }
210
211 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest006, TestSize.Level2)
212 {
213 LOG("--------HuksAdapterTest Test006--------");
214 LOG("--------generate_service_id--------");
215 struct service_id service_id = generate_service_id(&g_server_identity_004);
216 EXPECT_GT(service_id.length, 0);
217 LOG("--------HuksAdapterTest Test006--------");
218 }
219
220 static HWTEST_F(HuksAdapterTest, GenerateServiceIdTest007, TestSize.Level2)
221 {
222 LOG("--------HuksAdapterTest Test007--------");
223 LOG("--------generate_service_id--------");
224 struct service_id service_id = generate_service_id(&g_server_identity_005);
225 EXPECT_GT(service_id.length, 0);
226 LOG("--------HuksAdapterTest Test007--------");
227 }
228
229 static HWTEST_F(HuksAdapterTest, GenerateKeyAliasTest001, TestSize.Level2)
230 {
231 LOG("--------HuksAdapterTest Test008--------");
232 LOG("--------generate_key_alias--------");
233 enum huks_key_alias_type alias_type = KEY_ALIAS_ACCESSOR_PK;
234 struct service_id service_id = generate_service_id(&g_server_identity);
235 EXPECT_GT(service_id.length, 0);
236 struct hc_key_alias hc_key_alias = generate_key_alias(&service_id, &g_test_client_auth_id, alias_type);
237 EXPECT_GT(hc_key_alias.length, 0);
238 LOG("--------HuksAdapterTest Test008--------");
239 }
240
241 static HWTEST_F(HuksAdapterTest, GenerateKeyAliasTest002, TestSize.Level2)
242 {
243 LOG("--------HuksAdapterTest Test009--------");
244 LOG("--------generate_key_alias--------");
245 enum huks_key_alias_type alias_type = KEY_ALIAS_ACCESSOR_PK;
246 struct hc_key_alias hc_key_alias = generate_key_alias(nullptr, &g_test_client_auth_id, alias_type);
247 EXPECT_EQ(hc_key_alias.length, 0);
248 LOG("--------HuksAdapterTest Test009--------");
249 }
250
251 static HWTEST_F(HuksAdapterTest, GenerateKeyAliasTest003, TestSize.Level2)
252 {
253 LOG("--------HuksAdapterTest Test010--------");
254 LOG("--------generate_key_alias--------");
255 enum huks_key_alias_type alias_type = KEY_ALIAS_CONTROLLER_PK;
256 struct service_id service_id = {65, "as"};
257 struct hc_key_alias hc_key_alias = generate_key_alias(&service_id, &g_test_client_auth_id, alias_type);
258 EXPECT_EQ(hc_key_alias.length, 0);
259 LOG("--------HuksAdapterTest Test010--------");
260 }
261
262 static HWTEST_F(HuksAdapterTest, GenerateKeyAliasTest004, TestSize.Level2)
263 {
264 LOG("--------HuksAdapterTest Test011--------");
265 LOG("--------generate_key_alias--------");
266 enum huks_key_alias_type alias_type = KEY_ALIAS_CONTROLLER_PK;
267 struct service_id service_id = generate_service_id(&g_server_identity);
268 EXPECT_GT(service_id.length, 0);
269 struct hc_auth_id test_client_auth_id = {65, "as"};
270 struct hc_key_alias hc_key_alias = generate_key_alias(&service_id, &test_client_auth_id, alias_type);
271 EXPECT_EQ(hc_key_alias.length, 0);
272 LOG("--------HuksAdapterTest Test011--------");
273 }
274
275 static HWTEST_F(HuksAdapterTest, GenerateStKeyPairTest001, TestSize.Level2)
276 {
277 LOG("--------HuksAdapterTest Test012--------");
278 LOG("--------generate_st_key_pair--------");
279 struct st_key_pair *st_key_pair = static_cast<struct st_key_pair *>(MALLOC(sizeof(struct st_key_pair)));
280 (void)memset_s(st_key_pair, sizeof(*st_key_pair), 0, sizeof(*st_key_pair));
281 int32_t status = generate_st_key_pair(st_key_pair);
282 EXPECT_EQ(status, ERROR_CODE_SUCCESS);
283 FREE(st_key_pair);
284 LOG("--------HuksAdapterTest Test012--------");
285 }
286
287 static HWTEST_F(HuksAdapterTest, GenerateLtKeyPairTest001, TestSize.Level2)
288 {
289 LOG("--------HuksAdapterTest Test013--------");
290 LOG("--------generate_lt_key_pair--------");
291 struct service_id service_id = generate_service_id(&g_server_identity);
292 EXPECT_GT(service_id.length, 0);
293 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
294 int32_t ret = generate_lt_key_pair(&alias, &g_test_client_auth_id);
295 EXPECT_NE(ret, HC_OK);
296 LOG("--------HuksAdapterTest Test013--------");
297 }
298
299 static struct ltpk lt_public_key = { 0, {0} };
300
301 static HWTEST_F(HuksAdapterTest, ExportLtPublicKeyTest001, TestSize.Level2)
302 {
303 LOG("--------HuksAdapterTest Test014--------");
304 LOG("--------export_lt_public_key--------");
305 struct service_id service_id = generate_service_id(&g_server_identity);
306 EXPECT_GT(service_id.length, 0);
307 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
308 int32_t ret = export_lt_public_key(&alias, <_public_key);
309 EXPECT_NE(ret, HC_OK);
310 LOG("--------HuksAdapterTest Test014--------");
311 }
312
313 static HWTEST_F(HuksAdapterTest, DeleteLtPublicKeyTest001, TestSize.Level2)
314 {
315 LOG("--------HuksAdapterTest Test015--------");
316 LOG("--------delete_lt_public_key--------");
317 struct service_id service_id = generate_service_id(&g_server_identity);
318 EXPECT_GT(service_id.length, 0);
319 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
320 int32_t ret = delete_lt_public_key(&alias);
321 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
322 LOG("--------HuksAdapterTest Test015--------");
323 }
324
325 static HWTEST_F(HuksAdapterTest, DeleteLtPublicKeyTest002, TestSize.Level2)
326 {
327 LOG("--------HuksAdapterTest Test016--------");
328 LOG("--------delete_lt_public_key--------");
329 int32_t ret = delete_lt_public_key(nullptr);
330 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
331 LOG("--------HuksAdapterTest Test016--------");
332 }
333
334 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest001, TestSize.Level2)
335 {
336 LOG("--------HuksAdapterTest Test017--------");
337 LOG("--------import_lt_public_key--------");
338 struct service_id service_id = generate_service_id(&g_server_identity);
339 EXPECT_GT(service_id.length, 0);
340 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
341 int32_t userType = 1;
342 int32_t pairType = -1;
343 int32_t ret = import_lt_public_key(&alias, <_public_key, userType, pairType, &g_test_client_auth_id);
344 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
345 LOG("--------HuksAdapterTest Test017--------");
346 }
347
348 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest002, TestSize.Level2)
349 {
350 LOG("--------HuksAdapterTest Test018--------");
351 LOG("--------import_lt_public_key--------");
352 struct service_id service_id = generate_service_id(&g_server_identity);
353 EXPECT_GT(service_id.length, 0);
354 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
355 int32_t userType = -1;
356 int32_t pairType = 2;
357 int32_t ret = import_lt_public_key(&alias, <_public_key, userType, pairType, &g_test_client_auth_id);
358 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
359 LOG("--------HuksAdapterTest Test018--------");
360 }
361
362 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest003, TestSize.Level2)
363 {
364 LOG("--------HuksAdapterTest Test019--------");
365 LOG("--------import_lt_public_key--------");
366 struct service_id service_id = generate_service_id(&g_server_identity);
367 EXPECT_GT(service_id.length, 0);
368 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
369 int32_t userType = 7;
370 int32_t pairType = 0;
371 int32_t ret = import_lt_public_key(&alias, <_public_key, userType, pairType, &g_test_client_auth_id);
372 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
373 LOG("--------HuksAdapterTest Test019--------");
374 }
375
376 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest004, TestSize.Level2)
377 {
378 LOG("--------HuksAdapterTest Test020--------");
379 LOG("--------import_lt_public_key--------");
380 int32_t userType = 4;
381 int32_t pairType = 0;
382 int32_t ret = import_lt_public_key(nullptr, <_public_key, userType, pairType, &g_test_client_auth_id);
383 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
384 LOG("--------HuksAdapterTest Test020--------");
385 }
386
387 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest005, TestSize.Level2)
388 {
389 LOG("--------HuksAdapterTest Test021--------");
390 LOG("--------import_lt_public_key--------");
391 int32_t userType = 4;
392 int32_t pairType = 1;
393 struct service_id service_id = generate_service_id(&g_server_identity);
394 EXPECT_GT(service_id.length, 0);
395 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
396 int32_t ret = import_lt_public_key(&alias, nullptr, userType, pairType, &g_test_client_auth_id);
397 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
398 LOG("--------HuksAdapterTest Test021--------");
399 }
400
401 static HWTEST_F(HuksAdapterTest, ImportLtPublicKeyTest006, TestSize.Level2)
402 {
403 LOG("--------HuksAdapterTest Test022--------");
404 LOG("--------import_lt_public_key--------");
405 int32_t userType = 1;
406 int32_t pairType = 1;
407 struct service_id service_id = generate_service_id(&g_server_identity);
408 EXPECT_GT(service_id.length, 0);
409 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
410 int32_t ret = import_lt_public_key(&alias, <_public_key, userType, pairType, nullptr);
411 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
412 LOG("--------HuksAdapterTest Test022--------");
413 }
414
415 static HWTEST_F(HuksAdapterTest, CheckLtPublicKeyExistTest001, TestSize.Level2)
416 {
417 LOG("--------HuksAdapterTest Test023--------");
418 LOG("--------check_lt_public_key_exist--------");
419 struct service_id service_id = generate_service_id(&g_server_identity);
420 EXPECT_GT(service_id.length, 0);
421 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
422 int32_t ret = check_lt_public_key_exist(&alias);
423 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
424 LOG("--------HuksAdapterTest Test023--------");
425 }
426
427 static HWTEST_F(HuksAdapterTest, CheckLtPublicKeyExistTest002, TestSize.Level2)
428 {
429 LOG("--------HuksAdapterTest Test024--------");
430 LOG("--------check_lt_public_key_exist--------");
431 struct service_id service_id = generate_service_id(nullptr);
432 EXPECT_EQ(service_id.length, 0);
433 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
434 int32_t ret = check_lt_public_key_exist(&alias);
435 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
436 LOG("--------HuksAdapterTest Test024--------");
437 }
438
439 static HWTEST_F(HuksAdapterTest, CheckLtPublicKeyExistTest003, TestSize.Level2)
440 {
441 LOG("--------HuksAdapterTest Test025--------");
442 LOG("--------check_lt_public_key_exist--------");
443 int32_t ret = check_lt_public_key_exist(nullptr);
444 EXPECT_EQ(ret, HC_INPUT_ERROR);
445 struct hc_key_alias alias;
446 (void)memset_s(&alias, sizeof(alias), 0, sizeof(alias));
447 alias.length = 1;
448 ret = check_lt_public_key_exist(&alias);
449 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
450 LOG("--------HuksAdapterTest Test025--------");
451 }
452
453 static HWTEST_F(HuksAdapterTest, CheckKeyAliasIsOwnerTest001, TestSize.Level2)
454 {
455 LOG("--------HuksAdapterTest Test026--------");
456 LOG("--------check_key_alias_is_owner--------");
457 struct service_id service_id = generate_service_id(&g_server_identity);
458 EXPECT_GT(service_id.length, 0);
459 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
460 int32_t ret = check_key_alias_is_owner(&alias);
461 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
462 LOG("--------HuksAdapterTest Test026--------");
463 }
464
465 static HWTEST_F(HuksAdapterTest, CheckKeyAliasIsOwnerTest002, TestSize.Level2)
466 {
467 LOG("--------HuksAdapterTest Test027--------");
468 LOG("--------check_key_alias_is_owner--------");
469 struct service_id service_id = generate_service_id(nullptr);
470 EXPECT_EQ(service_id.length, 0);
471 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
472 int32_t ret = check_key_alias_is_owner(&alias);
473 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
474 LOG("--------HuksAdapterTest Test027--------");
475 }
476
477 static HWTEST_F(HuksAdapterTest, GetLtKeyInfoTest001, TestSize.Level2)
478 {
479 LOG("--------HuksAdapterTest Test028--------");
480 LOG("--------get_lt_key_info--------");
481 struct huks_key_type key_type;
482 struct hc_auth_id auth_id;
483 struct service_id service_id = generate_service_id(&g_server_identity);
484 EXPECT_GT(service_id.length, 0);
485 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
486 int32_t ret = get_lt_key_info(&alias, &key_type, &auth_id);
487 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
488 LOG("--------HuksAdapterTest Test028--------");
489 }
490
491 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest001, TestSize.Level2)
492 {
493 LOG("--------HuksAdapterTest Test030--------");
494 LOG("--------compute_sts_shared_secret--------");
495 struct st_key_pair st_key_pair;
496 int32_t ret = generate_st_key_pair(&st_key_pair);
497 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
498 struct sts_shared_secret shared_secret;
499 ret = compute_sts_shared_secret(&(st_key_pair.st_private_key), &(st_key_pair.st_public_key), &shared_secret);
500 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
501 LOG("--------HuksAdapterTest Test030--------");
502 }
503
504 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest002, TestSize.Level2)
505 {
506 LOG("--------HuksAdapterTest Test031--------");
507 LOG("--------compute_sts_shared_secret--------");
508 struct stpk peer_public_key = {4, {"9A87"}};
509 struct st_key_pair key_pair;
510 int32_t ret = generate_st_key_pair(&key_pair);
511 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
512 struct sts_shared_secret shared_secret;
513 ret = compute_sts_shared_secret(&(key_pair.st_private_key), &peer_public_key, &shared_secret);
514 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
515 LOG("--------HuksAdapterTest Test031--------");
516 }
517
518 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest003, TestSize.Level2)
519 {
520 LOG("--------HuksAdapterTest Test032--------");
521 LOG("--------compute_sts_shared_secret--------");
522 uint8_t temp[] = {"9A8781AE9ACFDBFD577DF72949A4731F"};
523 struct stpk stpk_test;
524 stpk_test.length = 32;
525 memcpy_s(stpk_test.stpk, sizeof(stpk_test.stpk), temp, stpk_test.length);
526 stpk_test.length = 0;
527 struct st_key_pair key_pair;
528 int32_t ret = generate_st_key_pair(&key_pair);
529 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
530 struct sts_shared_secret shared_secret;
531 ret = compute_sts_shared_secret(&(key_pair.st_private_key), &stpk_test, &shared_secret);
532 EXPECT_NE(ret, ERROR_CODE_FAILED);
533 LOG("--------HuksAdapterTest Test032--------");
534 }
535
536 static struct signature signature = {0, {0}};
537 static HWTEST_F(HuksAdapterTest, SignTest001, TestSize.Level2)
538 {
539 LOG("--------HuksAdapterTest Test033--------");
540 LOG("--------sign--------");
541 struct hc_call_back callBack = {
542 Transmit,
543 GetProtocolParams,
544 SetSessionKey,
545 SetServiceResult,
546 ConfirmReceiveRequest
547 };
548
549 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
550 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
551 int32_t ret = authenticate_peer(server, ¶ms);
552 EXPECT_EQ(ret, HC_OK);
553 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
554 struct uint8_buff message;
555 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
556 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
557 EXPECT_EQ(ret, HC_OK);
558 struct service_id service_id = generate_service_id(&g_server_identity);
559 EXPECT_GT(service_id.length, 0);
560 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
561 ret = sign(&alias, &message, &signature);
562 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
563 FREE(message.val);
564 LOG("--------HuksAdapterTest Test033--------");
565 }
566
567 static HWTEST_F(HuksAdapterTest, SignTest002, TestSize.Level2)
568 {
569 LOG("--------HuksAdapterTest Test034--------");
570 LOG("--------sign--------");
571 uint8_t dataMsg[] = {"9A8781AE9ACFDBFD577DF72949A4731F"};
572
573 struct uint8_buff message = {
574 dataMsg,
575 sizeof(dataMsg),
576 strlen(reinterpret_cast<char *>(dataMsg))
577 };
578
579 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
580 struct signature sign_result;
581 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
582 sign_result.length = HC_SIGNATURE_LEN;
583 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
584
585 struct service_id service_id = generate_service_id(&g_server_identity);
586 EXPECT_GT(service_id.length, 0);
587 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
588 int32_t ret = sign(&alias, &message, &sign_result);
589 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
590 LOG("--------HuksAdapterTest Test034--------");
591 }
592
593 static HWTEST_F(HuksAdapterTest, SignTest003, TestSize.Level2)
594 {
595 LOG("--------HuksAdapterTest Test035--------");
596 LOG("--------sign--------");
597 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
598 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
599 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
600
601 struct uint8_buff message = {
602 dataMsg,
603 sizeof(dataMsg),
604 strlen(reinterpret_cast<char *>(dataMsg))
605 };
606
607 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
608 struct signature sign_result;
609 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
610 sign_result.length = HC_SIGNATURE_LEN;
611 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
612 struct service_id service_id = generate_service_id(&g_server_identity);
613 EXPECT_GT(service_id.length, 0);
614 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
615 int32_t ret = sign(&alias, &message, &sign_result);
616 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
617 LOG("--------HuksAdapterTest Test035--------");
618 }
619
620 static HWTEST_F(HuksAdapterTest, VerifyTest001, TestSize.Level2)
621 {
622 LOG("--------HuksAdapterTest Test036--------");
623 LOG("--------verify--------");
624 struct hc_call_back callBack = {
625 Transmit,
626 GetProtocolParams,
627 SetSessionKey,
628 SetServiceResult,
629 ConfirmReceiveRequest
630 };
631
632 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
633 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
634 int32_t ret = authenticate_peer(server, ¶ms);
635 EXPECT_EQ(ret, HC_OK);
636 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
637 struct uint8_buff message;
638 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
639 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
640 EXPECT_EQ(ret, HC_OK);
641 struct service_id service_id = generate_service_id(&g_server_identity);
642 EXPECT_GT(service_id.length, 0);
643 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
644 ret = verify(&alias, HC_USER_TYPE_CONTROLLER, &message, &signature);
645 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
646 FREE(message.val);
647 LOG("--------HuksAdapterTest Test036--------");
648 }
649
650 static HWTEST_F(HuksAdapterTest, VerifyWithPublicKeyTest001, TestSize.Level2)
651 {
652 LOG("--------HuksAdapterTest Test037--------");
653 LOG("--------verify_with_public_key--------");
654 struct hc_call_back callBack = {
655 Transmit,
656 GetProtocolParams,
657 SetSessionKey,
658 SetServiceResult,
659 ConfirmReceiveRequest
660 };
661 int32_t userType = 1;
662 struct var_buffer public_key;
663 public_key.length = 128;
664 uint8_t dataMsg[] = {"BB4DA8D3B2E76EAF968C67DAFCC6ECD20A72668EA43220C2835AEDD6D84E2A314203E4"
665 "1D9F5E3D0C297CA1C0C61969ECC04658044FEF87FE141B0E374CAD5357"};
666 memcpy_s(public_key.data, sizeof(public_key.data), dataMsg, sizeof(public_key.data));
667 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
668
669 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
670 int32_t ret = authenticate_peer(server, ¶ms);
671 EXPECT_EQ(ret, HC_OK);
672 struct signature sign_result = {0, {0}};
673 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
674 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
675 sign_result.length = HC_SIGNATURE_LEN;
676 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
677
678 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
679 struct uint8_buff message;
680 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
681 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
682 EXPECT_EQ(ret, HC_OK);
683
684 ret = verify_with_public_key(userType, &message, &public_key, &sign_result);
685 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
686 FREE(message.val);
687 LOG("--------HuksAdapterTest Test037--------");
688 }
689
690 static HWTEST_F(HuksAdapterTest, VerifyWithPublicKeyTest002, TestSize.Level2)
691 {
692 LOG("--------HuksAdapterTest Test038--------");
693 LOG("--------verify_with_public_key--------");
694 int32_t userType = 1;
695 struct var_buffer public_key;
696 (void)memset_s(&public_key, sizeof(public_key), 0, sizeof(public_key));
697 public_key.length = 128;
698
699 struct signature sign_result;
700 (void)memset_s(&sign_result, sizeof(sign_result), 0, sizeof(sign_result));
701 sign_result.length = HC_SIGNATURE_LEN;
702
703 struct uint8_buff message;
704 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
705
706 int32_t ret = verify_with_public_key(userType, nullptr, &public_key, &sign_result);
707 EXPECT_EQ(ret, HC_INPUT_ERROR);
708 ret = verify_with_public_key(userType, &message, nullptr, &sign_result);
709 EXPECT_EQ(ret, HC_INPUT_ERROR);
710 ret = verify_with_public_key(userType, &message, &public_key, nullptr);
711 EXPECT_EQ(ret, HC_INPUT_ERROR);
712 LOG("--------HuksAdapterTest Test038--------");
713 }
714
715 static HWTEST_F(HuksAdapterTest, CheckDlSpekePublicKeyTest001, TestSize.Level2)
716 {
717 LOG("--------HuksAdapterTest Test039--------");
718 LOG("--------CheckDlSpekePublicKey--------");
719
720 int32_t result = CheckDlSpekePublicKey(nullptr, HC_BIG_PRIME_MAX_LEN_384);
721 EXPECT_EQ(result, HC_INPUT_PTR_NULL);
722 struct var_buffer key;
723 key.length = 500;
724 uint8_t data[] = {"123456789"};
725 memcpy_s(key.data, sizeof(data), data, sizeof(data));
726 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
727 EXPECT_EQ(result, HC_INPUT_ERROR);
728
729 key.length = 1;
730 key.data[0] = 0;
731 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
732 EXPECT_EQ(result, HC_MEMCPY_ERROR);
733
734 key.data[0] = 1;
735 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
736 EXPECT_EQ(result, HC_MEMCPY_ERROR);
737
738 key.data[0] = 0xFF;
739 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
740 EXPECT_EQ(result, HC_OK);
741 LOG("--------HuksAdapterTest Test039--------");
742 }
743
744 static HWTEST_F(HuksAdapterTest, CheckDlSpekePublicKeyTest002, TestSize.Level2)
745 {
746 LOG("--------HuksAdapterTest Test040--------");
747 LOG("--------CheckDlSpekePublicKey--------");
748
749 int32_t result = CheckDlSpekePublicKey(nullptr, HC_BIG_PRIME_MAX_LEN_384);
750 ASSERT_EQ(result, HC_INPUT_PTR_NULL);
751 struct var_buffer key;
752 key.length = 11;
753 uint8_t data[] = "123456789";
754 memcpy_s(key.data, sizeof(data), data, sizeof(data));
755 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_256);
756 ASSERT_EQ(result, HC_OK);
757 LOG("--------HuksAdapterTest Test040--------");
758 }
759
760 static HWTEST_F(HuksAdapterTest, CalBignumExpTest001, TestSize.Level2)
761 {
762 LOG("--------HuksAdapterTest Test041--------");
763 LOG("--------cal_bignum_exp--------");
764 struct var_buffer base;
765 base.length = 11;
766 uint8_t data[] = "123456789";
767 memcpy_s(base.data, sizeof(data), data, sizeof(data));
768
769 struct var_buffer exp;
770 exp.length = 1;
771 exp.data[0] = 0;
772
773 struct big_num out_result = {1, {0}};
774
775 int32_t result = cal_bignum_exp(nullptr, &exp, HC_BIG_PRIME_MAX_LEN_384, &out_result);
776 EXPECT_EQ(result, HC_INPUT_ERROR);
777 result = cal_bignum_exp(&base, nullptr, HC_BIG_PRIME_MAX_LEN_384, &out_result);
778 EXPECT_EQ(result, HC_INPUT_ERROR);
779 result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_256, nullptr);
780 EXPECT_EQ(result, HC_INPUT_ERROR);
781 LOG("--------HuksAdapterTest Test041--------");
782 }
783
784 static HWTEST_F(HuksAdapterTest, CalBignumExpTest002, TestSize.Level2)
785 {
786 LOG("--------HuksAdapterTest Test042--------");
787 LOG("--------cal_bignum_exp--------");
788 struct var_buffer base;
789 base.length = 11;
790 uint8_t data[] = "123456789";
791 memcpy_s(base.data, sizeof(data), data, sizeof(data));
792
793 struct var_buffer exp;
794 exp.length = 11;
795 exp.data[0] = 0;
796
797 struct big_num out_result = {1, {0}};
798
799 int32_t result = cal_bignum_exp(&base, &exp, 0, &out_result);
800 EXPECT_EQ(result, HC_LARGE_PRIME_NUMBER_LEN_UNSUPPORT);
801 result = cal_bignum_exp(&base, &exp, 1000, &out_result);
802 EXPECT_EQ(result, HC_LARGE_PRIME_NUMBER_LEN_UNSUPPORT);
803 LOG("--------HuksAdapterTest Test042--------");
804 }
805
806 static HWTEST_F(HuksAdapterTest, CalBignumExpTest003, TestSize.Level2)
807 {
808 LOG("--------HuksAdapterTest Test043--------");
809 LOG("--------cal_bignum_exp--------");
810 struct var_buffer base;
811 base.length = 11;
812 uint8_t data[] = "123456789";
813 memcpy_s(base.data, sizeof(data), data, sizeof(data));
814
815 struct var_buffer exp;
816 exp.length = 1;
817 exp.data[0] = 0;
818
819 struct big_num out_result = {0, {0}};
820
821 int32_t result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_256, &out_result);
822 EXPECT_NE(result, HC_INPUT_ERROR);
823 result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_384, &out_result);
824 EXPECT_NE(result, HC_INPUT_ERROR);
825 LOG("--------HuksAdapterTest Test043--------");
826 }
827
828 static HWTEST_F(HuksAdapterTest, ComputeHmacTest001, TestSize.Level2)
829 {
830 LOG("--------HuksAdapterTest Test044--------");
831 LOG("--------compute_hmac--------");
832 struct var_buffer key;
833 key.length = 11;
834 uint8_t data[] = "123456789";
835 memcpy_s(key.data, sizeof(data), data, sizeof(data));
836
837 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
838 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
839 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
840
841 struct uint8_buff message = {
842 dataMsg,
843 sizeof(dataMsg),
844 strlen(reinterpret_cast<char *>(dataMsg))
845 };
846
847 struct hmac out_hamc = {0, {0}};
848
849 int32_t result = compute_hmac(&key, &message, &out_hamc);
850 EXPECT_NE(result, ERROR_CODE_SUCCESS);
851 LOG("--------HuksAdapterTest Test044--------");
852 }
853
854 static HWTEST_F(HuksAdapterTest, ComputeHmacTest002, TestSize.Level2)
855 {
856 LOG("--------HuksAdapterTest Test045--------");
857 LOG("--------compute_hmac--------");
858 struct var_buffer key;
859 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
860 key.length = 16;
861
862 struct uint8_buff message;
863 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
864
865 struct hmac out_hamc;
866 (void)memset_s(&out_hamc, sizeof(out_hamc), 0, sizeof(out_hamc));
867
868 int32_t result = compute_hmac(nullptr, &message, &out_hamc);
869 EXPECT_EQ(result, HC_INPUT_ERROR);
870 result = compute_hmac(&key, nullptr, &out_hamc);
871 EXPECT_EQ(result, HC_INPUT_ERROR);
872 result = compute_hmac(&key, &message, nullptr);
873 EXPECT_EQ(result, HC_INPUT_ERROR);
874 LOG("--------HuksAdapterTest Test045--------");
875 }
876
877 static HWTEST_F(HuksAdapterTest, ComputeHkdfTest001, TestSize.Level2)
878 {
879 LOG("--------HuksAdapterTest Test046--------");
880 LOG("--------compute_hkdf--------");
881 struct var_buffer shared_secret;
882 shared_secret.length = 11;
883 uint8_t data[] = "123456789";
884 memcpy_s(shared_secret.data, sizeof(data), data, sizeof(data));
885
886 struct hc_salt salt = {1, {0}};
887 char keyInfo;
888 uint32_t hkdfLen = 1;
889
890 struct var_buffer out_hkdf;
891 out_hkdf.data[0] = 0;
892 out_hkdf.length = 64;
893
894 int32_t result = compute_hkdf(&shared_secret, &salt, &keyInfo, hkdfLen, &out_hkdf);
895 EXPECT_NE(result, ERROR_CODE_SUCCESS);
896 LOG("--------HuksAdapterTest Test046--------");
897 }
898
899 static HWTEST_F(HuksAdapterTest, AesGcmEncryptTest001, TestSize.Level2)
900 {
901 LOG("--------HuksAdapterTest Test047--------");
902 LOG("--------aes_gcm_encrypt--------");
903 struct var_buffer key;
904 key.length = 16;
905 uint8_t data[] = "123456789";
906 memcpy_s(key.data, sizeof(data), data, sizeof(data));
907
908 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
909 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
910 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
911
912 struct uint8_buff message = {
913 dataMsg,
914 sizeof(dataMsg),
915 strlen(reinterpret_cast<char *>(dataMsg))
916 };
917
918 struct aes_aad aad= {64, {0}};
919
920 struct uint8_buff out_plain;
921 out_plain.length = 1;
922 out_plain.size = 64;
923
924 int32_t result = aes_gcm_encrypt(&key, &message, &aad, &out_plain);
925 EXPECT_NE(result, ERROR_CODE_SUCCESS);
926 out_plain.length = 64;
927 result = aes_gcm_encrypt(&key, &message, &aad, &out_plain);
928 EXPECT_NE(result, ERROR_CODE_SUCCESS);
929 LOG("--------HuksAdapterTest Test047--------");
930 }
931
932 static HWTEST_F(HuksAdapterTest, AesGcmEncryptTest002, TestSize.Level2)
933 {
934 LOG("--------HuksAdapterTest Test048--------");
935 LOG("--------aes_gcm_encrypt--------");
936 struct var_buffer key;
937 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
938 key.length = 16;
939
940 struct uint8_buff message;
941 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
942
943 struct aes_aad aad;
944 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
945
946 struct uint8_buff out_plain;
947 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
948
949 int32_t result = aes_gcm_encrypt(nullptr, &message, &aad, &out_plain);
950 EXPECT_EQ(result, HC_INPUT_ERROR);
951 result = aes_gcm_encrypt(&key, nullptr, &aad, &out_plain);
952 EXPECT_EQ(result, HC_INPUT_ERROR);
953 result = aes_gcm_encrypt(&key, &message, nullptr, &out_plain);
954 EXPECT_EQ(result, HC_INPUT_ERROR);
955 result = aes_gcm_encrypt(&key, &message, &aad, nullptr);
956 EXPECT_EQ(result, HC_INPUT_ERROR);
957 LOG("--------HuksAdapterTest Test048--------");
958 }
959
960 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest001, TestSize.Level2)
961 {
962 LOG("--------HuksAdapterTest Test049--------");
963 LOG("--------aes_gcm_decrypt--------");
964 struct var_buffer key;
965 key.length = 11;
966 uint8_t data[] = "123456789";
967 memcpy_s(key.data, sizeof(data), data, sizeof(data));
968
969 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
970 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
971 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
972
973 struct uint8_buff message = {
974 dataMsg,
975 sizeof(dataMsg),
976 strlen(reinterpret_cast<char *>(dataMsg))
977 };
978
979 struct aes_aad aad = {1, {1}};
980
981 struct uint8_buff out_plain;
982 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
983 out_plain.size = 0;
984 out_plain.length = 0;
985
986 int32_t result = aes_gcm_decrypt(&key, &message, &aad, &out_plain);
987 EXPECT_NE(result, ERROR_CODE_SUCCESS);
988 LOG("--------HuksAdapterTest Test049--------");
989 }
990
991 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest002, TestSize.Level2)
992 {
993 LOG("--------HuksAdapterTest Test050--------");
994 LOG("--------aes_gcm_decrypt--------");
995 struct var_buffer key;
996 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
997 key.length = 16;
998
999 struct uint8_buff cipher;
1000 cipher.size = 64;
1001 cipher.length = 64;
1002
1003 struct aes_aad aad;
1004 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1005 aad.length = 64;
1006
1007 struct uint8_buff out_plain;
1008 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1009 out_plain.size = 64;
1010 out_plain.length = 64;
1011
1012 int32_t result = aes_gcm_decrypt(&key, &cipher, &aad, &out_plain);
1013 EXPECT_NE(result, ERROR_CODE_SUCCESS);
1014 LOG("--------HuksAdapterTest Test050--------");
1015 }
1016
1017 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest003, TestSize.Level2)
1018 {
1019 LOG("--------HuksAdapterTest Test051--------");
1020 LOG("--------aes_gcm_decrypt--------");
1021 struct var_buffer key;
1022 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
1023 key.length = 1;
1024
1025 struct uint8_buff cipher;
1026 cipher.size = 1;
1027 cipher.length = 30;
1028
1029 struct aes_aad aad;
1030 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1031 aad.length = 1;
1032
1033 struct uint8_buff out_plain;
1034 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1035 out_plain.size = 0;
1036 out_plain.length = 1;
1037
1038 int32_t result = aes_gcm_decrypt(&key, &cipher, &aad, &out_plain);
1039 EXPECT_NE(result, ERROR_CODE_SUCCESS);
1040 LOG("--------HuksAdapterTest Test051--------");
1041 }
1042
1043 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest004, TestSize.Level2)
1044 {
1045 LOG("--------HuksAdapterTest Test052--------");
1046 LOG("--------aes_gcm_decrypt--------");
1047 struct var_buffer key;
1048 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
1049 key.length = 16;
1050
1051 struct uint8_buff cipher;
1052 cipher.size = 64;
1053 cipher.length = 64;
1054
1055 struct aes_aad aad;
1056 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1057 aad.length = 64;
1058
1059 struct uint8_buff out_plain;
1060 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1061 out_plain.size = 64;
1062 out_plain.length = 64;
1063
1064 int32_t result = aes_gcm_decrypt(nullptr, &cipher, &aad, &out_plain);
1065 EXPECT_EQ(result, HC_INPUT_ERROR);
1066 result = aes_gcm_decrypt(&key, nullptr, &aad, &out_plain);
1067 EXPECT_EQ(result, HC_INPUT_ERROR);
1068 result = aes_gcm_decrypt(&key, &cipher, nullptr, &out_plain);
1069 EXPECT_EQ(result, HC_INPUT_ERROR);
1070 result = aes_gcm_decrypt(&key, &cipher, &aad, nullptr);
1071 EXPECT_EQ(result, HC_INPUT_ERROR);
1072 LOG("--------HuksAdapterTest Test052--------");
1073 }
1074
1075 static HWTEST_F(HuksAdapterTest, ReceiveDataTest001, TestSize.Level2)
1076 {
1077 LOG("--------HuksAdapterTest Test053--------");
1078 LOG("--------receive_data--------");
1079 struct hc_call_back callBack = {
1080 Transmit,
1081 GetProtocolParams,
1082 SetSessionKey,
1083 SetServiceResult,
1084 ConfirmReceiveRequest
1085 };
1086
1087 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1088 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
1089 int32_t ret = authenticate_peer(server, ¶ms);
1090 EXPECT_EQ(ret, HC_OK);
1091 uint8_t dataStr001[] = "{\"authForm\":0,\"message\":32785,\"payload\":{"
1092 "\"authData\":\"0CE64CAFFA6AD1146EDB618E6F1DA15183EFDCAE08F909A6ABA7B9F2676F4E"
1093 "4C2A280A720C3EBB069858DB473191ED51237E201CC697D3E10130CE8FB86FD57F66214643874"
1094 "AD17FE91EC3ACBC446CA666CDC5BDFB0EB5BE76DF673C\","
1095 "\"challenge\":\"C5914790E4A81F59F286F2F31415A590\","
1096 "\"epk\":\"8A870771CA779105041966DC462B3B12D7FF87129446F38D1AC39E1F408FEB0D\","
1097 "\"salt\":\"C8EA30CAE1C16CCEEB652DAE671A97A3\","
1098 "\"version\":{\"currentVersion\":\"1.0.0\",\"minVersion\":\"1.0.0\"},"
1099 "\"peerAuthId\":\"6433376364376365623839346634333933613239396566383532623466633"
1100 "3356131613064373763343861356233653062323539396162316436396232336136\","
1101 "\"peerUserType\":\"0\"}}";
1102
1103 struct uint8_buff data001 = {
1104 dataStr001,
1105 sizeof(dataStr001),
1106 strlen(reinterpret_cast<char *>(dataStr001))
1107 };
1108
1109 ret = receive_data(server, &data001);
1110 EXPECT_EQ(ret, HC_OK);
1111
1112 uint8_t dataStr002[] = "{\"authForm\":0,\"message\":32786,\"payload\":{"
1113 "\"authReturn\":\"57F9D09AA425FB83AB9BE2AF25FC9E5B82F630255AC62872447A9E5802\"}}";
1114
1115 struct uint8_buff data002 = {
1116 dataStr002,
1117 sizeof(dataStr002),
1118 strlen(reinterpret_cast<char *>(dataStr002))
1119 };
1120
1121 ret = receive_data(server, &data002);
1122 EXPECT_EQ(ret, HC_OK);
1123 destroy(&server);
1124 LOG("--------HuksAdapterTest Test053--------");
1125 }
1126
1127 static HWTEST_F(HuksAdapterTest, GenerateRandomTest001, TestSize.Level2)
1128 {
1129 LOG("--------HuksAdapterTest Test054--------");
1130 LOG("--------generate_random--------");
1131 uint32_t length = 0;
1132 struct random_value value = generate_random(length);
1133 EXPECT_EQ(value.length, 0);
1134 LOG("--------HuksAdapterTest Test054--------");
1135 }
1136
1137 static HWTEST_F(HuksAdapterTest, GenerateRandomTest002, TestSize.Level2)
1138 {
1139 LOG("--------HuksAdapterTest Test055--------");
1140 LOG("--------generate_random--------");
1141 uint32_t length = 33;
1142 struct random_value value = generate_random(length);
1143 EXPECT_EQ(value.length, 0);
1144 LOG("--------HuksAdapterTest Test055--------");
1145 }
1146
1147 static HWTEST_F(HuksAdapterTest, GenerateRandomTest003, TestSize.Level2)
1148 {
1149 LOG("--------HuksAdapterTest Test056--------");
1150 LOG("--------generate_random--------");
1151 uint32_t length = 32;
1152 struct random_value value = generate_random(length);
1153 EXPECT_GT(value.length, 0);
1154 LOG("--------HuksAdapterTest Test056--------");
1155 }
1156
GenerateSignMessage(hc_handle handle,struct uint8_buff * message)1157 int32_t GenerateSignMessage(hc_handle handle, struct uint8_buff *message)
1158 {
1159 LOG("Called generate sign message");
1160 check_ptr_return_val(handle, HC_INPUT_ERROR);
1161 check_ptr_return_val(message, HC_INPUT_ERROR);
1162 struct sts_client *stsClient = static_cast<struct sts_client *>(handle);
1163
1164 int len = stsClient->peer_public_key.length + stsClient->peer_id.length +
1165 stsClient->self_public_key.length + stsClient->self_id.length;
1166 uint8_t *info = static_cast<uint8_t *>(MALLOC(len));
1167 if (info == nullptr) {
1168 LOG("Malloc info failed");
1169 return HC_MALLOC_FAILED;
1170 }
1171
1172 int32_t pos = 0;
1173 (void)memcpy_s(info + pos, len - pos, stsClient->peer_public_key.stpk, stsClient->peer_public_key.length);
1174 pos += stsClient->peer_public_key.length;
1175 (void)memcpy_s(info + pos, len - pos, stsClient->peer_id.auth_id, stsClient->peer_id.length);
1176 pos += stsClient->peer_id.length;
1177 (void)memcpy_s(info + pos, len - pos, stsClient->self_public_key.stpk, stsClient->self_public_key.length);
1178 pos += stsClient->self_public_key.length;
1179 (void)memcpy_s(info + pos, len - pos, stsClient->self_id.auth_id, stsClient->self_id.length);
1180
1181 message->val = info;
1182 message->length = len;
1183 message->size = len;
1184 return HC_OK;
1185 }
1186
1187 /*------------------------auth_info------------------------*/
1188
1189 class AuthInfoTest : public testing::Test {
1190 public:
1191 static void SetUpTestCase(void);
1192 static void TearDownTestCase(void);
1193 void SetUp();
1194 void TearDown();
1195 };
1196
SetUpTestCase(void)1197 void AuthInfoTest::SetUpTestCase(void) {}
TearDownTestCase(void)1198 void AuthInfoTest::TearDownTestCase(void) {}
SetUp()1199 void AuthInfoTest::SetUp()
1200 {
1201 InitHcAuthId();
1202 }
TearDown()1203 void AuthInfoTest::TearDown() {}
1204
1205
1206 static HWTEST_F(AuthInfoTest, get_pake_session_key_test001, TestSize.Level2)
1207 {
1208 struct hc_call_back callBack = {
1209 Transmit,
1210 GetProtocolParams,
1211 SetSessionKey,
1212 SetServiceResult,
1213 ConfirmReceiveRequest
1214 };
1215
1216 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1217 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1218 struct pake_server pake_server;
1219 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1220 hichainTest->pake_server = &pake_server;
1221 const struct pake_session_key *key = get_pake_session_key(hichainTest);
1222 EXPECT_NE(key, nullptr);
1223 }
1224
1225 static HWTEST_F(AuthInfoTest, get_pake_session_key_test002, TestSize.Level2)
1226 {
1227 struct hc_call_back callBack = {
1228 Transmit,
1229 GetProtocolParams,
1230 SetSessionKey,
1231 SetServiceResult,
1232 ConfirmReceiveRequest
1233 };
1234
1235 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1236 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1237 const struct pake_session_key *key = get_pake_session_key(hichainTest);
1238 EXPECT_EQ(key, nullptr);
1239 }
1240
1241
1242 static HWTEST_F(AuthInfoTest, get_pake_self_challenge_test001, TestSize.Level2)
1243 {
1244 struct hc_call_back callBack = {
1245 Transmit,
1246 GetProtocolParams,
1247 SetSessionKey,
1248 SetServiceResult,
1249 ConfirmReceiveRequest
1250 };
1251
1252 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1253 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1254 struct pake_server pake_server;
1255 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1256 hichainTest->pake_server = &pake_server;
1257 const struct challenge *challenge = get_pake_self_challenge(hichainTest);
1258 EXPECT_NE(challenge, nullptr);
1259 }
1260
1261 static HWTEST_F(AuthInfoTest, get_pake_self_challenge_test002, TestSize.Level2)
1262 {
1263 struct hc_call_back callBack = {
1264 Transmit,
1265 GetProtocolParams,
1266 SetSessionKey,
1267 SetServiceResult,
1268 ConfirmReceiveRequest
1269 };
1270
1271 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1272 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1273 const struct challenge *challenge = get_pake_self_challenge(hichainTest);
1274 EXPECT_EQ(challenge, nullptr);
1275 }
1276
1277
1278 static HWTEST_F(AuthInfoTest, get_pake_peer_challenge_test001, TestSize.Level2)
1279 {
1280 struct hc_call_back callBack = {
1281 Transmit,
1282 GetProtocolParams,
1283 SetSessionKey,
1284 SetServiceResult,
1285 ConfirmReceiveRequest
1286 };
1287
1288 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1289 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1290 struct pake_server pake_server;
1291 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1292 hichainTest->pake_server = &pake_server;
1293 const struct challenge *challenge = get_pake_peer_challenge(hichainTest);
1294 EXPECT_NE(challenge, nullptr);
1295 }
1296
1297 static HWTEST_F(AuthInfoTest, get_pake_peer_challenge_test002, TestSize.Level2)
1298 {
1299 struct hc_call_back callBack = {
1300 Transmit,
1301 GetProtocolParams,
1302 SetSessionKey,
1303 SetServiceResult,
1304 ConfirmReceiveRequest
1305 };
1306
1307 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1308 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1309 const struct challenge *challenge = get_pake_peer_challenge(hichainTest);
1310 EXPECT_EQ(challenge, nullptr);
1311 }
1312
1313
1314 static HWTEST_F(AuthInfoTest, get_pake_self_auth_id_test001, TestSize.Level2)
1315 {
1316 struct hc_call_back callBack = {
1317 Transmit,
1318 GetProtocolParams,
1319 SetSessionKey,
1320 SetServiceResult,
1321 ConfirmReceiveRequest
1322 };
1323
1324 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1325 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1326 struct pake_server pake_server;
1327 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1328 hichainTest->pake_server = &pake_server;
1329 const struct hc_auth_id *hcAuthId = get_pake_self_auth_id(hichainTest);
1330 EXPECT_NE(hcAuthId, nullptr);
1331 }
1332
1333 static HWTEST_F(AuthInfoTest, get_pake_self_auth_id_test002, TestSize.Level2)
1334 {
1335 struct hc_call_back callBack = {
1336 Transmit,
1337 GetProtocolParams,
1338 SetSessionKey,
1339 SetServiceResult,
1340 ConfirmReceiveRequest
1341 };
1342
1343 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1344 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1345 const struct hc_auth_id *hcAuthId = get_pake_self_auth_id(hichainTest);
1346 EXPECT_EQ(hcAuthId, nullptr);
1347 }
1348
1349
1350 static HWTEST_F(AuthInfoTest, get_sts_session_key_test001, TestSize.Level2)
1351 {
1352 struct hc_call_back callBack = {
1353 Transmit,
1354 GetProtocolParams,
1355 SetSessionKey,
1356 SetServiceResult,
1357 ConfirmReceiveRequest
1358 };
1359
1360 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1361 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1362 struct sts_server sts_server;
1363 (void)memset_s(&sts_server, sizeof(sts_server), 0, sizeof(sts_server));
1364 hichainTest->sts_server = &sts_server;
1365 const struct sts_session_key *key = get_sts_session_key(hichainTest);
1366 EXPECT_NE(key, nullptr);
1367 }
1368
1369 static HWTEST_F(AuthInfoTest, get_sts_session_key_test002, TestSize.Level2)
1370 {
1371 struct hc_call_back callBack = {
1372 Transmit,
1373 GetProtocolParams,
1374 SetSessionKey,
1375 SetServiceResult,
1376 ConfirmReceiveRequest
1377 };
1378
1379 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1380 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1381 const struct sts_session_key *key = get_sts_session_key(hichainTest);
1382 EXPECT_EQ(key, nullptr);
1383 }
1384
1385 static HWTEST_F(AuthInfoTest, save_auth_info_test001, TestSize.Level2)
1386 {
1387 struct hc_call_back callBack = {
1388 Transmit,
1389 GetProtocolParams,
1390 SetSessionKey,
1391 SetServiceResult,
1392 ConfirmReceiveRequest
1393 };
1394
1395 int32_t pairType = 1;
1396 struct auth_info_cache cache;
1397 struct ltpk ltpk;
1398 (void)memset_s(<pk, sizeof(ltpk), 0, sizeof(ltpk));
1399 cache.user_type = HC_USER_TYPE_ACCESSORY;
1400 cache.auth_id = g_test_server_auth_id;
1401 cache.ltpk = ltpk;
1402 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1403 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1404 int32_t ret = save_auth_info(hichainTest, pairType, &cache);
1405 EXPECT_EQ(ret, HC_SAVE_LTPK_FAILED);
1406 }
1407
1408 static HWTEST_F(AuthInfoTest, save_auth_info_test002, TestSize.Level2)
1409 {
1410 int32_t pairType = 1;
1411 struct auth_info_cache cache;
1412 struct ltpk ltpk;
1413 (void)memset_s(<pk, sizeof(ltpk), 0, sizeof(ltpk));
1414 cache.user_type = HC_USER_TYPE_CONTROLLER;
1415 struct hc_auth_id auth_id;
1416 (void)memset_s(&auth_id, sizeof(auth_id), 0, sizeof(auth_id));
1417 cache.auth_id = auth_id;
1418 cache.ltpk = ltpk;
1419 int32_t ret = save_auth_info(nullptr, pairType, &cache);
1420 EXPECT_EQ(ret, HC_GEN_SERVICE_ID_FAILED);
1421 }
1422 }