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