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 uint32_t count = 0;
507 enum huks_key_alias_type alias_type = KEY_ALIAS_CONTROLLER_PK;
508 int32_t ret = get_lt_public_key_list(&g_test_client_auth_id, alias_type, *g_authIdList, &count);
509 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
510 LOG("--------HuksAdapterTest Test029--------");
511 }
512
513 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest001, TestSize.Level2)
514 {
515 LOG("--------HuksAdapterTest Test030--------");
516 LOG("--------compute_sts_shared_secret--------");
517 struct st_key_pair st_key_pair;
518 int32_t ret = generate_st_key_pair(&st_key_pair);
519 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
520 struct sts_shared_secret shared_secret;
521 ret = compute_sts_shared_secret(&(st_key_pair.st_private_key), &(st_key_pair.st_public_key), &shared_secret);
522 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
523 LOG("--------HuksAdapterTest Test030--------");
524 }
525
526 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest002, TestSize.Level2)
527 {
528 LOG("--------HuksAdapterTest Test031--------");
529 LOG("--------compute_sts_shared_secret--------");
530 struct stpk peer_public_key = {4, {"9A87"}};
531 struct st_key_pair key_pair;
532 int32_t ret = generate_st_key_pair(&key_pair);
533 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
534 struct sts_shared_secret shared_secret;
535 ret = compute_sts_shared_secret(&(key_pair.st_private_key), &peer_public_key, &shared_secret);
536 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
537 LOG("--------HuksAdapterTest Test031--------");
538 }
539
540 static HWTEST_F(HuksAdapterTest, ComputeStsSharedSecretTest003, TestSize.Level2)
541 {
542 LOG("--------HuksAdapterTest Test032--------");
543 LOG("--------compute_sts_shared_secret--------");
544 uint8_t temp[] = {"9A8781AE9ACFDBFD577DF72949A4731F"};
545 struct stpk stpk_test;
546 stpk_test.length = 32;
547 memcpy_s(stpk_test.stpk, sizeof(stpk_test.stpk), temp, stpk_test.length);
548 stpk_test.length = 0;
549 struct st_key_pair key_pair;
550 int32_t ret = generate_st_key_pair(&key_pair);
551 EXPECT_EQ(ret, ERROR_CODE_SUCCESS);
552 struct sts_shared_secret shared_secret;
553 ret = compute_sts_shared_secret(&(key_pair.st_private_key), &stpk_test, &shared_secret);
554 EXPECT_NE(ret, ERROR_CODE_FAILED);
555 LOG("--------HuksAdapterTest Test032--------");
556 }
557
558 static struct signature signature = {0, {0}};
559 static HWTEST_F(HuksAdapterTest, SignTest001, TestSize.Level2)
560 {
561 LOG("--------HuksAdapterTest Test033--------");
562 LOG("--------sign--------");
563 struct hc_call_back callBack = {
564 Transmit,
565 GetProtocolParams,
566 SetSessionKey,
567 SetServiceResult,
568 ConfirmReceiveRequest
569 };
570
571 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
572 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
573 int32_t ret = authenticate_peer(server, ¶ms);
574 EXPECT_EQ(ret, HC_OK);
575 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
576 struct uint8_buff message;
577 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
578 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
579 EXPECT_EQ(ret, HC_OK);
580 struct service_id service_id = generate_service_id(&g_server_identity);
581 EXPECT_GT(service_id.length, 0);
582 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
583 ret = sign(&alias, &message, &signature);
584 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
585 FREE(message.val);
586 LOG("--------HuksAdapterTest Test033--------");
587 }
588
589 static HWTEST_F(HuksAdapterTest, SignTest002, TestSize.Level2)
590 {
591 LOG("--------HuksAdapterTest Test034--------");
592 LOG("--------sign--------");
593 uint8_t dataMsg[] = {"9A8781AE9ACFDBFD577DF72949A4731F"};
594
595 struct uint8_buff message = {
596 dataMsg,
597 sizeof(dataMsg),
598 strlen(reinterpret_cast<char *>(dataMsg))
599 };
600
601 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
602 struct signature sign_result;
603 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
604 sign_result.length = HC_SIGNATURE_LEN;
605 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
606
607 struct service_id service_id = generate_service_id(&g_server_identity);
608 EXPECT_GT(service_id.length, 0);
609 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
610 int32_t ret = sign(&alias, &message, &sign_result);
611 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
612 LOG("--------HuksAdapterTest Test034--------");
613 }
614
615 static HWTEST_F(HuksAdapterTest, SignTest003, TestSize.Level2)
616 {
617 LOG("--------HuksAdapterTest Test035--------");
618 LOG("--------sign--------");
619 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
620 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
621 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
622
623 struct uint8_buff message = {
624 dataMsg,
625 sizeof(dataMsg),
626 strlen(reinterpret_cast<char *>(dataMsg))
627 };
628
629 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
630 struct signature sign_result;
631 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
632 sign_result.length = HC_SIGNATURE_LEN;
633 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
634 struct service_id service_id = generate_service_id(&g_server_identity);
635 EXPECT_GT(service_id.length, 0);
636 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
637 int32_t ret = sign(&alias, &message, &sign_result);
638 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
639 LOG("--------HuksAdapterTest Test035--------");
640 }
641
642 static HWTEST_F(HuksAdapterTest, VerifyTest001, TestSize.Level2)
643 {
644 LOG("--------HuksAdapterTest Test036--------");
645 LOG("--------verify--------");
646 struct hc_call_back callBack = {
647 Transmit,
648 GetProtocolParams,
649 SetSessionKey,
650 SetServiceResult,
651 ConfirmReceiveRequest
652 };
653
654 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
655 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
656 int32_t ret = authenticate_peer(server, ¶ms);
657 EXPECT_EQ(ret, HC_OK);
658 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
659 struct uint8_buff message;
660 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
661 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
662 EXPECT_EQ(ret, HC_OK);
663 struct service_id service_id = generate_service_id(&g_server_identity);
664 EXPECT_GT(service_id.length, 0);
665 struct hc_key_alias alias = generate_key_alias(&service_id, &g_test_client_auth_id, KEY_ALIAS_ACCESSOR_PK);
666 ret = verify(&alias, HC_USER_TYPE_CONTROLLER, &message, &signature);
667 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
668 FREE(message.val);
669 LOG("--------HuksAdapterTest Test036--------");
670 }
671
672 static HWTEST_F(HuksAdapterTest, VerifyWithPublicKeyTest001, TestSize.Level2)
673 {
674 LOG("--------HuksAdapterTest Test037--------");
675 LOG("--------verify_with_public_key--------");
676 struct hc_call_back callBack = {
677 Transmit,
678 GetProtocolParams,
679 SetSessionKey,
680 SetServiceResult,
681 ConfirmReceiveRequest
682 };
683 int32_t userType = 1;
684 struct var_buffer public_key;
685 public_key.length = 128;
686 uint8_t dataMsg[] = {"BB4DA8D3B2E76EAF968C67DAFCC6ECD20A72668EA43220C2835AEDD6D84E2A314203E4"
687 "1D9F5E3D0C297CA1C0C61969ECC04658044FEF87FE141B0E374CAD5357"};
688 memcpy_s(public_key.data, sizeof(public_key.data), dataMsg, sizeof(public_key.data));
689 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
690
691 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
692 int32_t ret = authenticate_peer(server, ¶ms);
693 EXPECT_EQ(ret, HC_OK);
694 struct signature sign_result = {0, {0}};
695 uint8_t dataStr[] = {"9A8781AE9ACFDBFD577DF72949A4731FE73208026B2BBD7822CFE170F01C5C09"};
696 (void)memset_s(&sign_result, sizeof(struct signature), 0, sizeof(struct signature));
697 sign_result.length = HC_SIGNATURE_LEN;
698 memcpy_s(sign_result.signature, sizeof(sign_result.signature), dataStr, HC_SIGNATURE_LEN);
699
700 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
701 struct uint8_buff message;
702 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
703 ret = GenerateSignMessage(reinterpret_cast<void *>(hichainTest->sts_client), &message);
704 EXPECT_EQ(ret, HC_OK);
705
706 ret = verify_with_public_key(userType, &message, &public_key, &sign_result);
707 EXPECT_NE(ret, ERROR_CODE_SUCCESS);
708 FREE(message.val);
709 LOG("--------HuksAdapterTest Test037--------");
710 }
711
712 static HWTEST_F(HuksAdapterTest, VerifyWithPublicKeyTest002, TestSize.Level2)
713 {
714 LOG("--------HuksAdapterTest Test038--------");
715 LOG("--------verify_with_public_key--------");
716 int32_t userType = 1;
717 struct var_buffer public_key;
718 (void)memset_s(&public_key, sizeof(public_key), 0, sizeof(public_key));
719 public_key.length = 128;
720
721 struct signature sign_result;
722 (void)memset_s(&sign_result, sizeof(sign_result), 0, sizeof(sign_result));
723 sign_result.length = HC_SIGNATURE_LEN;
724
725 struct uint8_buff message;
726 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
727
728 int32_t ret = verify_with_public_key(userType, nullptr, &public_key, &sign_result);
729 EXPECT_EQ(ret, HC_INPUT_ERROR);
730 ret = verify_with_public_key(userType, &message, nullptr, &sign_result);
731 EXPECT_EQ(ret, HC_INPUT_ERROR);
732 ret = verify_with_public_key(userType, &message, &public_key, nullptr);
733 EXPECT_EQ(ret, HC_INPUT_ERROR);
734 LOG("--------HuksAdapterTest Test038--------");
735 }
736
737 static HWTEST_F(HuksAdapterTest, CheckDlSpekePublicKeyTest001, TestSize.Level2)
738 {
739 LOG("--------HuksAdapterTest Test039--------");
740 LOG("--------CheckDlSpekePublicKey--------");
741
742 int32_t result = CheckDlSpekePublicKey(nullptr, HC_BIG_PRIME_MAX_LEN_384);
743 EXPECT_EQ(result, HC_INPUT_PTR_NULL);
744 struct var_buffer key;
745 key.length = 500;
746 uint8_t data[] = {"123456789"};
747 memcpy_s(key.data, sizeof(data), data, sizeof(data));
748 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
749 EXPECT_EQ(result, HC_INPUT_ERROR);
750
751 key.length = 1;
752 key.data[0] = 0;
753 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
754 EXPECT_EQ(result, HC_MEMCPY_ERROR);
755
756 key.data[0] = 1;
757 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
758 EXPECT_EQ(result, HC_MEMCPY_ERROR);
759
760 key.data[0] = 0xFF;
761 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_384);
762 EXPECT_EQ(result, HC_OK);
763 LOG("--------HuksAdapterTest Test039--------");
764 }
765
766 static HWTEST_F(HuksAdapterTest, CheckDlSpekePublicKeyTest002, TestSize.Level2)
767 {
768 LOG("--------HuksAdapterTest Test040--------");
769 LOG("--------CheckDlSpekePublicKey--------");
770
771 int32_t result = CheckDlSpekePublicKey(nullptr, HC_BIG_PRIME_MAX_LEN_384);
772 ASSERT_EQ(result, HC_INPUT_PTR_NULL);
773 struct var_buffer key;
774 key.length = 11;
775 uint8_t data[] = "123456789";
776 memcpy_s(key.data, sizeof(data), data, sizeof(data));
777 result = CheckDlSpekePublicKey(&key, HC_BIG_PRIME_MAX_LEN_256);
778 ASSERT_EQ(result, HC_OK);
779 LOG("--------HuksAdapterTest Test040--------");
780 }
781
782 static HWTEST_F(HuksAdapterTest, CalBignumExpTest001, TestSize.Level2)
783 {
784 LOG("--------HuksAdapterTest Test041--------");
785 LOG("--------cal_bignum_exp--------");
786 struct var_buffer base;
787 base.length = 11;
788 uint8_t data[] = "123456789";
789 memcpy_s(base.data, sizeof(data), data, sizeof(data));
790
791 struct var_buffer exp;
792 exp.length = 1;
793 exp.data[0] = 0;
794
795 struct big_num out_result = {1, {0}};
796
797 int32_t result = cal_bignum_exp(nullptr, &exp, HC_BIG_PRIME_MAX_LEN_384, &out_result);
798 EXPECT_EQ(result, HC_INPUT_ERROR);
799 result = cal_bignum_exp(&base, nullptr, HC_BIG_PRIME_MAX_LEN_384, &out_result);
800 EXPECT_EQ(result, HC_INPUT_ERROR);
801 result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_256, nullptr);
802 EXPECT_EQ(result, HC_INPUT_ERROR);
803 LOG("--------HuksAdapterTest Test041--------");
804 }
805
806 static HWTEST_F(HuksAdapterTest, CalBignumExpTest002, TestSize.Level2)
807 {
808 LOG("--------HuksAdapterTest Test042--------");
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 = 11;
817 exp.data[0] = 0;
818
819 struct big_num out_result = {1, {0}};
820
821 int32_t result = cal_bignum_exp(&base, &exp, 0, &out_result);
822 EXPECT_EQ(result, HC_LARGE_PRIME_NUMBER_LEN_UNSUPPORT);
823 result = cal_bignum_exp(&base, &exp, 1000, &out_result);
824 EXPECT_EQ(result, HC_LARGE_PRIME_NUMBER_LEN_UNSUPPORT);
825 LOG("--------HuksAdapterTest Test042--------");
826 }
827
828 static HWTEST_F(HuksAdapterTest, CalBignumExpTest003, TestSize.Level2)
829 {
830 LOG("--------HuksAdapterTest Test043--------");
831 LOG("--------cal_bignum_exp--------");
832 struct var_buffer base;
833 base.length = 11;
834 uint8_t data[] = "123456789";
835 memcpy_s(base.data, sizeof(data), data, sizeof(data));
836
837 struct var_buffer exp;
838 exp.length = 1;
839 exp.data[0] = 0;
840
841 struct big_num out_result = {0, {0}};
842
843 int32_t result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_256, &out_result);
844 EXPECT_NE(result, HC_INPUT_ERROR);
845 result = cal_bignum_exp(&base, &exp, HC_BIG_PRIME_MAX_LEN_384, &out_result);
846 EXPECT_NE(result, HC_INPUT_ERROR);
847 LOG("--------HuksAdapterTest Test043--------");
848 }
849
850 static HWTEST_F(HuksAdapterTest, ComputeHmacTest001, TestSize.Level2)
851 {
852 LOG("--------HuksAdapterTest Test044--------");
853 LOG("--------compute_hmac--------");
854 struct var_buffer key;
855 key.length = 11;
856 uint8_t data[] = "123456789";
857 memcpy_s(key.data, sizeof(data), data, sizeof(data));
858
859 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
860 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
861 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
862
863 struct uint8_buff message = {
864 dataMsg,
865 sizeof(dataMsg),
866 strlen(reinterpret_cast<char *>(dataMsg))
867 };
868
869 struct hmac out_hamc = {0, {0}};
870
871 int32_t result = compute_hmac(&key, &message, &out_hamc);
872 EXPECT_NE(result, ERROR_CODE_SUCCESS);
873 LOG("--------HuksAdapterTest Test044--------");
874 }
875
876 static HWTEST_F(HuksAdapterTest, ComputeHmacTest002, TestSize.Level2)
877 {
878 LOG("--------HuksAdapterTest Test045--------");
879 LOG("--------compute_hmac--------");
880 struct var_buffer key;
881 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
882 key.length = 16;
883
884 struct uint8_buff message;
885 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
886
887 struct hmac out_hamc;
888 (void)memset_s(&out_hamc, sizeof(out_hamc), 0, sizeof(out_hamc));
889
890 int32_t result = compute_hmac(nullptr, &message, &out_hamc);
891 EXPECT_EQ(result, HC_INPUT_ERROR);
892 result = compute_hmac(&key, nullptr, &out_hamc);
893 EXPECT_EQ(result, HC_INPUT_ERROR);
894 result = compute_hmac(&key, &message, nullptr);
895 EXPECT_EQ(result, HC_INPUT_ERROR);
896 LOG("--------HuksAdapterTest Test045--------");
897 }
898
899 static HWTEST_F(HuksAdapterTest, ComputeHkdfTest001, TestSize.Level2)
900 {
901 LOG("--------HuksAdapterTest Test046--------");
902 LOG("--------compute_hkdf--------");
903 struct var_buffer shared_secret;
904 shared_secret.length = 11;
905 uint8_t data[] = "123456789";
906 memcpy_s(shared_secret.data, sizeof(data), data, sizeof(data));
907
908 struct hc_salt salt = {1, {0}};
909 char keyInfo;
910 uint32_t hkdfLen = 1;
911
912 struct var_buffer out_hkdf;
913 out_hkdf.data[0] = 0;
914 out_hkdf.length = 64;
915
916 int32_t result = compute_hkdf(&shared_secret, &salt, &keyInfo, hkdfLen, &out_hkdf);
917 EXPECT_NE(result, ERROR_CODE_SUCCESS);
918 LOG("--------HuksAdapterTest Test046--------");
919 }
920
921 static HWTEST_F(HuksAdapterTest, AesGcmEncryptTest001, TestSize.Level2)
922 {
923 LOG("--------HuksAdapterTest Test047--------");
924 LOG("--------aes_gcm_encrypt--------");
925 struct var_buffer key;
926 key.length = 16;
927 uint8_t data[] = "123456789";
928 memcpy_s(key.data, sizeof(data), data, sizeof(data));
929
930 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
931 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
932 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
933
934 struct uint8_buff message = {
935 dataMsg,
936 sizeof(dataMsg),
937 strlen(reinterpret_cast<char *>(dataMsg))
938 };
939
940 struct aes_aad aad= {64, {0}};
941
942 struct uint8_buff out_plain;
943 out_plain.length = 1;
944 out_plain.size = 64;
945
946 int32_t result = aes_gcm_encrypt(&key, &message, &aad, &out_plain);
947 EXPECT_NE(result, ERROR_CODE_SUCCESS);
948 out_plain.length = 64;
949 result = aes_gcm_encrypt(&key, &message, &aad, &out_plain);
950 EXPECT_NE(result, ERROR_CODE_SUCCESS);
951 LOG("--------HuksAdapterTest Test047--------");
952 }
953
954 static HWTEST_F(HuksAdapterTest, AesGcmEncryptTest002, TestSize.Level2)
955 {
956 LOG("--------HuksAdapterTest Test048--------");
957 LOG("--------aes_gcm_encrypt--------");
958 struct var_buffer key;
959 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
960 key.length = 16;
961
962 struct uint8_buff message;
963 (void)memset_s(&message, sizeof(message), 0, sizeof(message));
964
965 struct aes_aad aad;
966 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
967
968 struct uint8_buff out_plain;
969 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
970
971 int32_t result = aes_gcm_encrypt(nullptr, &message, &aad, &out_plain);
972 EXPECT_EQ(result, HC_INPUT_ERROR);
973 result = aes_gcm_encrypt(&key, nullptr, &aad, &out_plain);
974 EXPECT_EQ(result, HC_INPUT_ERROR);
975 result = aes_gcm_encrypt(&key, &message, nullptr, &out_plain);
976 EXPECT_EQ(result, HC_INPUT_ERROR);
977 result = aes_gcm_encrypt(&key, &message, &aad, nullptr);
978 EXPECT_EQ(result, HC_INPUT_ERROR);
979 LOG("--------HuksAdapterTest Test048--------");
980 }
981
982 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest001, TestSize.Level2)
983 {
984 LOG("--------HuksAdapterTest Test049--------");
985 LOG("--------aes_gcm_decrypt--------");
986 struct var_buffer key;
987 key.length = 11;
988 uint8_t data[] = "123456789";
989 memcpy_s(key.data, sizeof(data), data, sizeof(data));
990
991 uint8_t dataMsg[] = "{\"message\":32770,\"payload\":{"
992 "\"kcfData\":\"4A4EB6622524CBBF7DC96412A82BF4CB6022F50226A201DB3B3C55B4F0707345\","
993 "\"challenge\":\"E01AE0AA018ECDA852ACA4CCA45FCC56\"}}";
994
995 struct uint8_buff message = {
996 dataMsg,
997 sizeof(dataMsg),
998 strlen(reinterpret_cast<char *>(dataMsg))
999 };
1000
1001 struct aes_aad aad = {1, {1}};
1002
1003 struct uint8_buff out_plain;
1004 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1005 out_plain.size = 0;
1006 out_plain.length = 0;
1007
1008 int32_t result = aes_gcm_decrypt(&key, &message, &aad, &out_plain);
1009 EXPECT_NE(result, ERROR_CODE_SUCCESS);
1010 LOG("--------HuksAdapterTest Test049--------");
1011 }
1012
1013 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest002, TestSize.Level2)
1014 {
1015 LOG("--------HuksAdapterTest Test050--------");
1016 LOG("--------aes_gcm_decrypt--------");
1017 struct var_buffer key;
1018 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
1019 key.length = 16;
1020
1021 struct uint8_buff cipher;
1022 cipher.size = 64;
1023 cipher.length = 64;
1024
1025 struct aes_aad aad;
1026 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1027 aad.length = 64;
1028
1029 struct uint8_buff out_plain;
1030 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1031 out_plain.size = 64;
1032 out_plain.length = 64;
1033
1034 int32_t result = aes_gcm_decrypt(&key, &cipher, &aad, &out_plain);
1035 EXPECT_NE(result, ERROR_CODE_SUCCESS);
1036 LOG("--------HuksAdapterTest Test050--------");
1037 }
1038
1039 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest003, TestSize.Level2)
1040 {
1041 LOG("--------HuksAdapterTest Test051--------");
1042 LOG("--------aes_gcm_decrypt--------");
1043 struct var_buffer key;
1044 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
1045 key.length = 1;
1046
1047 struct uint8_buff cipher;
1048 cipher.size = 1;
1049 cipher.length = 30;
1050
1051 struct aes_aad aad;
1052 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1053 aad.length = 1;
1054
1055 struct uint8_buff out_plain;
1056 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1057 out_plain.size = 0;
1058 out_plain.length = 1;
1059
1060 int32_t result = aes_gcm_decrypt(&key, &cipher, &aad, &out_plain);
1061 EXPECT_NE(result, ERROR_CODE_SUCCESS);
1062 LOG("--------HuksAdapterTest Test051--------");
1063 }
1064
1065 static HWTEST_F(HuksAdapterTest, AesGcmDecryptTest004, TestSize.Level2)
1066 {
1067 LOG("--------HuksAdapterTest Test052--------");
1068 LOG("--------aes_gcm_decrypt--------");
1069 struct var_buffer key;
1070 (void)memset_s(&key, sizeof(key), 0, sizeof(key));
1071 key.length = 16;
1072
1073 struct uint8_buff cipher;
1074 cipher.size = 64;
1075 cipher.length = 64;
1076
1077 struct aes_aad aad;
1078 (void)memset_s(&aad, sizeof(aad), 0, sizeof(aad));
1079 aad.length = 64;
1080
1081 struct uint8_buff out_plain;
1082 (void)memset_s(&out_plain, sizeof(out_plain), 0, sizeof(out_plain));
1083 out_plain.size = 64;
1084 out_plain.length = 64;
1085
1086 int32_t result = aes_gcm_decrypt(nullptr, &cipher, &aad, &out_plain);
1087 EXPECT_EQ(result, HC_INPUT_ERROR);
1088 result = aes_gcm_decrypt(&key, nullptr, &aad, &out_plain);
1089 EXPECT_EQ(result, HC_INPUT_ERROR);
1090 result = aes_gcm_decrypt(&key, &cipher, nullptr, &out_plain);
1091 EXPECT_EQ(result, HC_INPUT_ERROR);
1092 result = aes_gcm_decrypt(&key, &cipher, &aad, nullptr);
1093 EXPECT_EQ(result, HC_INPUT_ERROR);
1094 LOG("--------HuksAdapterTest Test052--------");
1095 }
1096
1097 static HWTEST_F(HuksAdapterTest, ReceiveDataTest001, TestSize.Level2)
1098 {
1099 LOG("--------HuksAdapterTest Test053--------");
1100 LOG("--------receive_data--------");
1101 struct hc_call_back callBack = {
1102 Transmit,
1103 GetProtocolParams,
1104 SetSessionKey,
1105 SetServiceResult,
1106 ConfirmReceiveRequest
1107 };
1108
1109 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1110 struct operation_parameter params = {g_test_server_auth_id, g_test_client_auth_id, KEY_LEN};
1111 int32_t ret = authenticate_peer(server, ¶ms);
1112 EXPECT_EQ(ret, HC_OK);
1113 uint8_t dataStr001[] = "{\"authForm\":0,\"message\":32785,\"payload\":{"
1114 "\"authData\":\"0CE64CAFFA6AD1146EDB618E6F1DA15183EFDCAE08F909A6ABA7B9F2676F4E"
1115 "4C2A280A720C3EBB069858DB473191ED51237E201CC697D3E10130CE8FB86FD57F66214643874"
1116 "AD17FE91EC3ACBC446CA666CDC5BDFB0EB5BE76DF673C\","
1117 "\"challenge\":\"C5914790E4A81F59F286F2F31415A590\","
1118 "\"epk\":\"8A870771CA779105041966DC462B3B12D7FF87129446F38D1AC39E1F408FEB0D\","
1119 "\"salt\":\"C8EA30CAE1C16CCEEB652DAE671A97A3\","
1120 "\"version\":{\"currentVersion\":\"1.0.0\",\"minVersion\":\"1.0.0\"},"
1121 "\"peerAuthId\":\"6433376364376365623839346634333933613239396566383532623466633"
1122 "3356131613064373763343861356233653062323539396162316436396232336136\","
1123 "\"peerUserType\":\"0\"}}";
1124
1125 struct uint8_buff data001 = {
1126 dataStr001,
1127 sizeof(dataStr001),
1128 strlen(reinterpret_cast<char *>(dataStr001))
1129 };
1130
1131 ret = receive_data(server, &data001);
1132 EXPECT_EQ(ret, HC_OK);
1133
1134 uint8_t dataStr002[] = "{\"authForm\":0,\"message\":32786,\"payload\":{"
1135 "\"authReturn\":\"57F9D09AA425FB83AB9BE2AF25FC9E5B82F630255AC62872447A9E5802\"}}";
1136
1137 struct uint8_buff data002 = {
1138 dataStr002,
1139 sizeof(dataStr002),
1140 strlen(reinterpret_cast<char *>(dataStr002))
1141 };
1142
1143 ret = receive_data(server, &data002);
1144 EXPECT_EQ(ret, HC_OK);
1145 destroy(&server);
1146 LOG("--------HuksAdapterTest Test053--------");
1147 }
1148
1149 static HWTEST_F(HuksAdapterTest, GenerateRandomTest001, TestSize.Level2)
1150 {
1151 LOG("--------HuksAdapterTest Test054--------");
1152 LOG("--------generate_random--------");
1153 uint32_t length = 0;
1154 struct random_value value = generate_random(length);
1155 EXPECT_EQ(value.length, 0);
1156 LOG("--------HuksAdapterTest Test054--------");
1157 }
1158
1159 static HWTEST_F(HuksAdapterTest, GenerateRandomTest002, TestSize.Level2)
1160 {
1161 LOG("--------HuksAdapterTest Test055--------");
1162 LOG("--------generate_random--------");
1163 uint32_t length = 33;
1164 struct random_value value = generate_random(length);
1165 EXPECT_EQ(value.length, 0);
1166 LOG("--------HuksAdapterTest Test055--------");
1167 }
1168
1169 static HWTEST_F(HuksAdapterTest, GenerateRandomTest003, TestSize.Level2)
1170 {
1171 LOG("--------HuksAdapterTest Test056--------");
1172 LOG("--------generate_random--------");
1173 uint32_t length = 32;
1174 struct random_value value = generate_random(length);
1175 EXPECT_GT(value.length, 0);
1176 LOG("--------HuksAdapterTest Test056--------");
1177 }
1178
GenerateSignMessage(hc_handle handle,struct uint8_buff * message)1179 int32_t GenerateSignMessage(hc_handle handle, struct uint8_buff *message)
1180 {
1181 LOG("Called generate sign message");
1182 check_ptr_return_val(handle, HC_INPUT_ERROR);
1183 check_ptr_return_val(message, HC_INPUT_ERROR);
1184 struct sts_client *stsClient = static_cast<struct sts_client *>(handle);
1185
1186 int len = stsClient->peer_public_key.length + stsClient->peer_id.length +
1187 stsClient->self_public_key.length + stsClient->self_id.length;
1188 uint8_t *info = static_cast<uint8_t *>(MALLOC(len));
1189 if (info == nullptr) {
1190 LOG("Malloc info failed");
1191 return HC_MALLOC_FAILED;
1192 }
1193
1194 int32_t pos = 0;
1195 (void)memcpy_s(info + pos, len - pos, stsClient->peer_public_key.stpk, stsClient->peer_public_key.length);
1196 pos += stsClient->peer_public_key.length;
1197 (void)memcpy_s(info + pos, len - pos, stsClient->peer_id.auth_id, stsClient->peer_id.length);
1198 pos += stsClient->peer_id.length;
1199 (void)memcpy_s(info + pos, len - pos, stsClient->self_public_key.stpk, stsClient->self_public_key.length);
1200 pos += stsClient->self_public_key.length;
1201 (void)memcpy_s(info + pos, len - pos, stsClient->self_id.auth_id, stsClient->self_id.length);
1202
1203 message->val = info;
1204 message->length = len;
1205 message->size = len;
1206 return HC_OK;
1207 }
1208
1209 /*------------------------auth_info------------------------*/
1210
1211 class AuthInfoTest : public testing::Test {
1212 public:
1213 static void SetUpTestCase(void);
1214 static void TearDownTestCase(void);
1215 void SetUp();
1216 void TearDown();
1217 };
1218
SetUpTestCase(void)1219 void AuthInfoTest::SetUpTestCase(void) {}
TearDownTestCase(void)1220 void AuthInfoTest::TearDownTestCase(void) {}
SetUp()1221 void AuthInfoTest::SetUp()
1222 {
1223 InitHcAuthId();
1224 }
TearDown()1225 void AuthInfoTest::TearDown() {}
1226
1227
1228 static HWTEST_F(AuthInfoTest, get_pake_session_key_test001, TestSize.Level2)
1229 {
1230 struct hc_call_back callBack = {
1231 Transmit,
1232 GetProtocolParams,
1233 SetSessionKey,
1234 SetServiceResult,
1235 ConfirmReceiveRequest
1236 };
1237
1238 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1239 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1240 struct pake_server pake_server;
1241 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1242 hichainTest->pake_server = &pake_server;
1243 const struct pake_session_key *key = get_pake_session_key(hichainTest);
1244 EXPECT_NE(key, nullptr);
1245 }
1246
1247 static HWTEST_F(AuthInfoTest, get_pake_session_key_test002, TestSize.Level2)
1248 {
1249 struct hc_call_back callBack = {
1250 Transmit,
1251 GetProtocolParams,
1252 SetSessionKey,
1253 SetServiceResult,
1254 ConfirmReceiveRequest
1255 };
1256
1257 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1258 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1259 const struct pake_session_key *key = get_pake_session_key(hichainTest);
1260 EXPECT_EQ(key, nullptr);
1261 }
1262
1263
1264 static HWTEST_F(AuthInfoTest, get_pake_self_challenge_test001, TestSize.Level2)
1265 {
1266 struct hc_call_back callBack = {
1267 Transmit,
1268 GetProtocolParams,
1269 SetSessionKey,
1270 SetServiceResult,
1271 ConfirmReceiveRequest
1272 };
1273
1274 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1275 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1276 struct pake_server pake_server;
1277 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1278 hichainTest->pake_server = &pake_server;
1279 const struct challenge *challenge = get_pake_self_challenge(hichainTest);
1280 EXPECT_NE(challenge, nullptr);
1281 }
1282
1283 static HWTEST_F(AuthInfoTest, get_pake_self_challenge_test002, TestSize.Level2)
1284 {
1285 struct hc_call_back callBack = {
1286 Transmit,
1287 GetProtocolParams,
1288 SetSessionKey,
1289 SetServiceResult,
1290 ConfirmReceiveRequest
1291 };
1292
1293 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1294 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1295 const struct challenge *challenge = get_pake_self_challenge(hichainTest);
1296 EXPECT_EQ(challenge, nullptr);
1297 }
1298
1299
1300 static HWTEST_F(AuthInfoTest, get_pake_peer_challenge_test001, TestSize.Level2)
1301 {
1302 struct hc_call_back callBack = {
1303 Transmit,
1304 GetProtocolParams,
1305 SetSessionKey,
1306 SetServiceResult,
1307 ConfirmReceiveRequest
1308 };
1309
1310 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1311 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1312 struct pake_server pake_server;
1313 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1314 hichainTest->pake_server = &pake_server;
1315 const struct challenge *challenge = get_pake_peer_challenge(hichainTest);
1316 EXPECT_NE(challenge, nullptr);
1317 }
1318
1319 static HWTEST_F(AuthInfoTest, get_pake_peer_challenge_test002, TestSize.Level2)
1320 {
1321 struct hc_call_back callBack = {
1322 Transmit,
1323 GetProtocolParams,
1324 SetSessionKey,
1325 SetServiceResult,
1326 ConfirmReceiveRequest
1327 };
1328
1329 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1330 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1331 const struct challenge *challenge = get_pake_peer_challenge(hichainTest);
1332 EXPECT_EQ(challenge, nullptr);
1333 }
1334
1335
1336 static HWTEST_F(AuthInfoTest, get_pake_self_auth_id_test001, TestSize.Level2)
1337 {
1338 struct hc_call_back callBack = {
1339 Transmit,
1340 GetProtocolParams,
1341 SetSessionKey,
1342 SetServiceResult,
1343 ConfirmReceiveRequest
1344 };
1345
1346 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1347 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1348 struct pake_server pake_server;
1349 (void)memset_s(&pake_server, sizeof(pake_server), 0, sizeof(pake_server));
1350 hichainTest->pake_server = &pake_server;
1351 const struct hc_auth_id *hcAuthId = get_pake_self_auth_id(hichainTest);
1352 EXPECT_NE(hcAuthId, nullptr);
1353 }
1354
1355 static HWTEST_F(AuthInfoTest, get_pake_self_auth_id_test002, TestSize.Level2)
1356 {
1357 struct hc_call_back callBack = {
1358 Transmit,
1359 GetProtocolParams,
1360 SetSessionKey,
1361 SetServiceResult,
1362 ConfirmReceiveRequest
1363 };
1364
1365 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1366 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1367 const struct hc_auth_id *hcAuthId = get_pake_self_auth_id(hichainTest);
1368 EXPECT_EQ(hcAuthId, nullptr);
1369 }
1370
1371
1372 static HWTEST_F(AuthInfoTest, get_sts_session_key_test001, TestSize.Level2)
1373 {
1374 struct hc_call_back callBack = {
1375 Transmit,
1376 GetProtocolParams,
1377 SetSessionKey,
1378 SetServiceResult,
1379 ConfirmReceiveRequest
1380 };
1381
1382 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1383 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1384 struct sts_server sts_server;
1385 (void)memset_s(&sts_server, sizeof(sts_server), 0, sizeof(sts_server));
1386 hichainTest->sts_server = &sts_server;
1387 const struct sts_session_key *key = get_sts_session_key(hichainTest);
1388 EXPECT_NE(key, nullptr);
1389 }
1390
1391 static HWTEST_F(AuthInfoTest, get_sts_session_key_test002, TestSize.Level2)
1392 {
1393 struct hc_call_back callBack = {
1394 Transmit,
1395 GetProtocolParams,
1396 SetSessionKey,
1397 SetServiceResult,
1398 ConfirmReceiveRequest
1399 };
1400
1401 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1402 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1403 const struct sts_session_key *key = get_sts_session_key(hichainTest);
1404 EXPECT_EQ(key, nullptr);
1405 }
1406
1407 static HWTEST_F(AuthInfoTest, save_auth_info_test001, TestSize.Level2)
1408 {
1409 struct hc_call_back callBack = {
1410 Transmit,
1411 GetProtocolParams,
1412 SetSessionKey,
1413 SetServiceResult,
1414 ConfirmReceiveRequest
1415 };
1416
1417 int32_t pairType = 1;
1418 struct auth_info_cache cache;
1419 struct ltpk ltpk;
1420 (void)memset_s(<pk, sizeof(ltpk), 0, sizeof(ltpk));
1421 cache.user_type = HC_USER_TYPE_ACCESSORY;
1422 cache.auth_id = g_test_server_auth_id;
1423 cache.ltpk = ltpk;
1424 hc_handle server = get_instance(&g_server_identity, HC_CENTRE, &callBack);
1425 struct hichain *hichainTest = reinterpret_cast<struct hichain *>(server);
1426 int32_t ret = save_auth_info(hichainTest, pairType, &cache);
1427 EXPECT_EQ(ret, HC_SAVE_LTPK_FAILED);
1428 }
1429
1430 static HWTEST_F(AuthInfoTest, save_auth_info_test002, TestSize.Level2)
1431 {
1432 int32_t pairType = 1;
1433 struct auth_info_cache cache;
1434 struct ltpk ltpk;
1435 (void)memset_s(<pk, sizeof(ltpk), 0, sizeof(ltpk));
1436 cache.user_type = HC_USER_TYPE_CONTROLLER;
1437 struct hc_auth_id auth_id;
1438 (void)memset_s(&auth_id, sizeof(auth_id), 0, sizeof(auth_id));
1439 cache.auth_id = auth_id;
1440 cache.ltpk = ltpk;
1441 int32_t ret = save_auth_info(nullptr, pairType, &cache);
1442 EXPECT_EQ(ret, HC_GEN_SERVICE_ID_FAILED);
1443 }
1444 }