1 /*
2 * Copyright (C) 2024-2025 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 <cinttypes>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include "device_auth_defines.h"
20 #include "device_auth.h"
21 #include "string_util.h"
22 #include "cert_operation.h"
23 #include "identity_manager.h"
24 #include "identity_common.h"
25 #include "../../../../services/legacy/identity_manager/src/identity_cred.c"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace {
31 static const int TEST_SIGNATURE_LEN = 32;
32 static const int TEST_OS_ACCOUNT_ID = 100;
33
34 #define TEST_GROUP_ID "TestGroupId"
35 #define TEST_DEVICE_ID "TestDeviceId"
36 #define TEST_USER_ID "TestUsertId"
37 #define TEST_REQUEST_JSON_STR "TestRequestJsonStr"
38 #define TEST_PIN_CODE "11111"
39
40 #define UNSUPPORTED_TYPE 0
41 #define UNSUPPORTED_PROOF_TYPE (-1)
42 #define TEST_BYTE "TestBytes"
43 #define TEST_CRED_ID "TestCredId"
44
45 extern "C" int32_t GenerateCertInfo(const Uint8Buff *pkInfoStr, const Uint8Buff *pkInfoSignature, CertInfo *certInfo);
46
47 class IdentityManagerTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase()55 void IdentityManagerTest::SetUpTestCase() {}
TearDownTestCase()56 void IdentityManagerTest::TearDownTestCase() {}
57
SetUp()58 void IdentityManagerTest::SetUp()
59 {
60 int32_t ret = InitDeviceAuthService();
61 ASSERT_EQ(ret, HC_SUCCESS);
62 }
63
TearDown()64 void IdentityManagerTest::TearDown()
65 {
66 DestroyDeviceAuthService();
67 }
68
69 HWTEST_F(IdentityManagerTest, IdentityManagerTest001, TestSize.Level0)
70 {
71 int32_t ret = AddCertInfoToJson(nullptr, nullptr);
72 EXPECT_NE(ret, HC_SUCCESS);
73 CertInfo info = { { nullptr, 0 }, { nullptr, 0 }, P256 };
74 ret = AddCertInfoToJson(&info, nullptr);
75 EXPECT_NE(ret, HC_SUCCESS);
76 CJson *pkInfoJson = CreateJson();
77 ASSERT_NE(pkInfoJson, nullptr);
78 char *pkInfoStr = PackJsonToString(pkInfoJson);
79 FreeJson(pkInfoJson);
80 ASSERT_NE(pkInfoStr, nullptr);
81 info.pkInfoStr.val = (uint8_t *)pkInfoStr;
82 info.pkInfoStr.length = strlen(pkInfoStr) + 1;
83 info.signAlg = P256;
84 CJson *out = CreateJson();
85 ASSERT_NE(out, nullptr);
86 ret = AddCertInfoToJson(&info, out);
87 EXPECT_NE(ret, HC_SUCCESS);
88 uint8_t testSignature[TEST_SIGNATURE_LEN] = { 0 };
89 info.pkInfoSignature.val = testSignature;
90 info.pkInfoSignature.length = TEST_SIGNATURE_LEN;
91 ret = AddCertInfoToJson(&info, out);
92 EXPECT_EQ(ret, HC_SUCCESS);
93 FreeJsonString(pkInfoStr);
94 FreeJson(out);
95 }
96
97 HWTEST_F(IdentityManagerTest, IdentityManagerTest002, TestSize.Level0)
98 {
99 Uint8Buff pkInfoBuf = { nullptr, 0 };
100 CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
101 int32_t ret = GenerateCertInfo(&pkInfoBuf, nullptr, &certInfo);
102 EXPECT_NE(ret, HC_SUCCESS);
103 CJson *pkInfoJson = CreateJson();
104 ASSERT_NE(pkInfoJson, nullptr);
105 char *pkInfoStr = PackJsonToString(pkInfoJson);
106 FreeJson(pkInfoJson);
107 pkInfoBuf.val = (uint8_t *)pkInfoStr;
108 pkInfoBuf.length = HcStrlen(pkInfoStr) + 1;
109 Uint8Buff pkInfoSigBuf = { nullptr, 0 };
110 ret = GenerateCertInfo(&pkInfoBuf, &pkInfoSigBuf, &certInfo);
111 EXPECT_NE(ret, HC_SUCCESS);
112 FreeJsonString(pkInfoStr);
113 HcFree(certInfo.pkInfoStr.val);
114 }
115
116 HWTEST_F(IdentityManagerTest, IdentityManagerTest003, TestSize.Level0)
117 {
118 IdentityInfo *info = CreateIdentityInfo();
119 ASSERT_NE(info, nullptr);
120 int32_t ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID,
121 TEST_DEVICE_ID, true, info);
122 EXPECT_NE(ret, HC_SUCCESS);
123 ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, nullptr, TEST_DEVICE_ID, true, info);
124 EXPECT_NE(ret, HC_SUCCESS);
125 ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID, nullptr, true, info);
126 DestroyIdentityInfo(info);
127 EXPECT_NE(ret, HC_SUCCESS);
128 ret = GetAccountRelatedCredInfo(TEST_OS_ACCOUNT_ID, TEST_GROUP_ID, TEST_DEVICE_ID, true, nullptr);
129 EXPECT_NE(ret, HC_SUCCESS);
130 ret = GetAccountAsymSharedSecret(TEST_OS_ACCOUNT_ID, nullptr, nullptr, nullptr);
131 EXPECT_NE(ret, HC_SUCCESS);
132 CertInfo peerCertInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
133 ret = GetAccountAsymSharedSecret(TEST_OS_ACCOUNT_ID, nullptr, &peerCertInfo, nullptr);
134 EXPECT_NE(ret, HC_SUCCESS);
135 ret = GetAccountSymSharedSecret(nullptr, nullptr, nullptr);
136 EXPECT_NE(ret, HC_SUCCESS);
137 CJson *in = CreateJson();
138 ASSERT_NE(in, nullptr);
139 ret = GetAccountSymSharedSecret(in, nullptr, nullptr);
140 EXPECT_NE(ret, HC_SUCCESS);
141 CJson *urlJson = CreateJson();
142 ASSERT_NE(urlJson, nullptr);
143 ret = GetAccountSymSharedSecret(in, urlJson, nullptr);
144 EXPECT_NE(ret, HC_SUCCESS);
145 FreeJson(in);
146 FreeJson(urlJson);
147 ret = GetAccountAsymCredInfo(TEST_OS_ACCOUNT_ID, nullptr, nullptr);
148 EXPECT_NE(ret, HC_SUCCESS);
149 CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
150 ret = GetAccountAsymCredInfo(TEST_OS_ACCOUNT_ID, &certInfo, nullptr);
151 EXPECT_NE(ret, HC_SUCCESS);
152 ret = GetAccountSymCredInfoByPeerUrl(nullptr, nullptr, nullptr);
153 EXPECT_NE(ret, HC_SUCCESS);
154 in = CreateJson();
155 ASSERT_NE(in, nullptr);
156 ret = GetAccountSymCredInfoByPeerUrl(in, nullptr, nullptr);
157 EXPECT_NE(ret, HC_SUCCESS);
158 urlJson = CreateJson();
159 ASSERT_NE(urlJson, nullptr);
160 ret = GetAccountSymCredInfoByPeerUrl(in, urlJson, nullptr);
161 EXPECT_NE(ret, HC_SUCCESS);
162 FreeJson(in);
163 FreeJson(urlJson);
164 }
165
166 HWTEST_F(IdentityManagerTest, IdentityManagerTest004, TestSize.Level0)
167 {
168 const CredentialOperator *credOperator = GetCredentialOperator();
169 EXPECT_NE(credOperator, nullptr);
170 int32_t ret = credOperator->queryCredential(TEST_REQUEST_JSON_STR, nullptr);
171 EXPECT_NE(ret, HC_SUCCESS);
172 }
173
174 HWTEST_F(IdentityManagerTest, IdentityManagerTest005, TestSize.Level0)
175 {
176 Uint8Buff srcPsk = { nullptr, 0 };
177 Uint8Buff sharedSecret = { nullptr, 0 };
178 int32_t ret = ConvertPsk(&srcPsk, &sharedSecret);
179 EXPECT_NE(ret, HC_SUCCESS);
180 }
181
182 HWTEST_F(IdentityManagerTest, IdentityManagerTest006, TestSize.Level0)
183 {
184 const AuthIdentity *identity = GetGroupAuthIdentity();
185 EXPECT_NE(identity, nullptr);
186 int32_t ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
187 EXPECT_NE(ret, HC_SUCCESS);
188 CJson *in = CreateJson();
189 ASSERT_NE(in, nullptr);
190 ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
191 EXPECT_NE(ret, HC_SUCCESS);
192 Uint8Buff presharedUrl = { nullptr, 0 };
193 ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
194 EXPECT_NE(ret, HC_SUCCESS);
195 ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
196 EXPECT_NE(ret, HC_SUCCESS);
197 ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
198 EXPECT_NE(ret, HC_SUCCESS);
199 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
200 EXPECT_NE(ret, HC_SUCCESS);
201 ret = identity->getCredInfoByPeerCert(nullptr, nullptr, nullptr);
202 EXPECT_NE(ret, HC_SUCCESS);
203 ret = identity->getCredInfoByPeerCert(in, nullptr, nullptr);
204 EXPECT_NE(ret, HC_SUCCESS);
205 CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
206 ret = identity->getCredInfoByPeerCert(in, &certInfo, nullptr);
207 EXPECT_NE(ret, HC_SUCCESS);
208 ret = identity->getSharedSecretByPeerCert(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
209 EXPECT_NE(ret, HC_SUCCESS);
210 ret = identity->getSharedSecretByPeerCert(in, nullptr, ALG_EC_SPEKE, nullptr);
211 EXPECT_NE(ret, HC_SUCCESS);
212 CertInfo peerCertInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
213 ret = identity->getSharedSecretByPeerCert(in, &peerCertInfo, ALG_EC_SPEKE, nullptr);
214 EXPECT_NE(ret, HC_SUCCESS);
215 FreeJson(in);
216 }
217
218 HWTEST_F(IdentityManagerTest, IdentityManagerTest007, TestSize.Level0)
219 {
220 const AuthIdentity *identity = GetP2pAuthIdentity();
221 EXPECT_NE(identity, nullptr);
222 CJson *in = CreateJson();
223 ASSERT_NE(in, nullptr);
224 int32_t ret = identity->getCredInfosByPeerIdentity(in, nullptr);
225 EXPECT_NE(ret, HC_SUCCESS);
226 (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
227 (void)AddStringToJson(in, FIELD_PEER_CONN_DEVICE_ID, TEST_DEVICE_ID);
228 ret = identity->getCredInfosByPeerIdentity(in, nullptr);
229 EXPECT_NE(ret, HC_SUCCESS);
230 (void)AddIntToJson(in, FIELD_ACQURIED_TYPE, ACQUIRE_TYPE_INVALID);
231 ret = identity->getCredInfosByPeerIdentity(in, nullptr);
232 EXPECT_NE(ret, HC_SUCCESS);
233 FreeJson(in);
234 ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
235 EXPECT_NE(ret, HC_SUCCESS);
236 in = CreateJson();
237 ASSERT_NE(in, nullptr);
238 ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
239 EXPECT_NE(ret, HC_SUCCESS);
240 Uint8Buff presharedUrl = { nullptr, 0 };
241 ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
242 EXPECT_NE(ret, HC_SUCCESS);
243 IdentityInfo *info = nullptr;
244 ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, &info);
245 EXPECT_NE(ret, HC_SUCCESS);
246 (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
247 Uint8Buff sharedSecret = { nullptr, 0 };
248 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
249 EXPECT_NE(ret, HC_SUCCESS);
250 ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
251 EXPECT_NE(ret, HC_SUCCESS);
252 ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
253 EXPECT_NE(ret, HC_SUCCESS);
254 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
255 EXPECT_NE(ret, HC_SUCCESS);
256 FreeJson(in);
257 }
258
259 HWTEST_F(IdentityManagerTest, IdentityManagerTest008, TestSize.Level0)
260 {
261 const AuthIdentity *identity = GetPinAuthIdentity();
262 EXPECT_NE(identity, nullptr);
263 int32_t ret = identity->getCredInfoByPeerUrl(nullptr, nullptr, nullptr);
264 EXPECT_NE(ret, HC_SUCCESS);
265 CJson *in = CreateJson();
266 ASSERT_NE(in, nullptr);
267 ret = identity->getCredInfoByPeerUrl(in, nullptr, nullptr);
268 EXPECT_NE(ret, HC_SUCCESS);
269 Uint8Buff presharedUrl = { nullptr, 0 };
270 ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, nullptr);
271 EXPECT_NE(ret, HC_SUCCESS);
272 IdentityInfo *info = nullptr;
273 CJson *urlJson = CreateJson();
274 ASSERT_NE(urlJson, nullptr);
275 char *urlStr = PackJsonToString(urlJson);
276 FreeJson(urlJson);
277 ASSERT_NE(urlStr, nullptr);
278 presharedUrl.val = (uint8_t *)urlStr;
279 presharedUrl.length = HcStrlen(urlStr) + 1;
280 ret = identity->getCredInfoByPeerUrl(in, &presharedUrl, &info);
281 EXPECT_NE(ret, HC_SUCCESS);
282 ret = identity->getSharedSecretByUrl(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
283 EXPECT_NE(ret, HC_SUCCESS);
284 ret = identity->getSharedSecretByUrl(in, nullptr, ALG_EC_SPEKE, nullptr);
285 EXPECT_NE(ret, HC_SUCCESS);
286 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
287 EXPECT_NE(ret, HC_SUCCESS);
288 (void)AddStringToJson(in, FIELD_PIN_CODE, TEST_PIN_CODE);
289 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_ISO, nullptr);
290 EXPECT_NE(ret, HC_SUCCESS);
291 ret = identity->getSharedSecretByUrl(in, &presharedUrl, ALG_EC_SPEKE, nullptr);
292 EXPECT_NE(ret, HC_SUCCESS);
293 FreeJson(in);
294 FreeJsonString(urlStr);
295 }
296
297 class IdentityCredTest : public testing::Test {
298 public:
299 static void SetUpTestCase();
300 static void TearDownTestCase();
301 void SetUp();
302 void TearDown();
303 };
304
SetUpTestCase()305 void IdentityCredTest::SetUpTestCase() {}
TearDownTestCase()306 void IdentityCredTest::TearDownTestCase() {}
307
SetUp()308 void IdentityCredTest::SetUp()
309 {
310 int32_t ret = InitDeviceAuthService();
311 ASSERT_EQ(ret, HC_SUCCESS);
312 }
313
TearDown()314 void IdentityCredTest::TearDown()
315 {
316 DestroyDeviceAuthService();
317 }
318
319 HWTEST_F(IdentityCredTest, IdentityCredTest001, TestSize.Level0)
320 {
321 char* urlStr = nullptr;
322 int32_t ret = CreateUrlStr(ACCOUNT_UNRELATED, KEY_TYPE_SYM, &urlStr);
323 EXPECT_EQ(ret, HC_SUCCESS);
324 FreeJsonString(urlStr);
325 ret = CreateUrlStr(ACCOUNT_RELATED, KEY_TYPE_SYM, &urlStr);
326 EXPECT_EQ(ret, HC_SUCCESS);
327 FreeJsonString(urlStr);
328 }
329
330 HWTEST_F(IdentityCredTest, IdentityCredTest002, TestSize.Level0)
331 {
332 IdentityProofType tmpType;
333 int32_t ret = ConvertISProofTypeToCertType(PROOF_TYPE_PSK, &tmpType);
334 EXPECT_EQ(ret, HC_SUCCESS);
335 ret = ConvertISProofTypeToCertType(PROOF_TYPE_PKI, &tmpType);
336 EXPECT_EQ(ret, HC_SUCCESS);
337 ret = ConvertISProofTypeToCertType(UNSUPPORTED_TYPE, &tmpType);
338 EXPECT_EQ(ret, HC_ERR_NOT_SUPPORT);
339 }
340
341 HWTEST_F(IdentityCredTest, IdentityCredTest003, TestSize.Level0)
342 {
343 Algorithm algType;
344 int32_t ret = ConvertISAlgToCertAlg(ALGO_TYPE_P256, &algType);
345 EXPECT_EQ(ret, HC_SUCCESS);
346 ret = ConvertISAlgToCertAlg(UNSUPPORTED_TYPE, &algType);
347 EXPECT_NE(ret, HC_SUCCESS);
348 }
349
350 HWTEST_F(IdentityCredTest, IdentityCredTest004, TestSize.Level0)
351 {
352 IdentityInfo *info = CreateIdentityInfo();
353 int32_t ret = ISSetISOEntity(info);
354 EXPECT_EQ(ret, HC_SUCCESS);
355 DestroyIdentityInfo(info);
356 }
357
358 HWTEST_F(IdentityCredTest, IdentityCredTest005, TestSize.Level0)
359 {
360 IdentityInfo *info = CreateIdentityInfo();
361 int32_t ret = ISSetEcSpekeEntity(info, false);
362 EXPECT_EQ(ret, HC_SUCCESS);
363 DestroyIdentityInfo(info);
364
365 info = CreateIdentityInfo();
366 ret = ISSetEcSpekeEntity(info, true);
367 EXPECT_EQ(ret, HC_SUCCESS);
368 DestroyIdentityInfo(info);
369 }
370
371 HWTEST_F(IdentityCredTest, IdentityCredTest006, TestSize.Level0)
372 {
373 IdentityInfo *info = CreateIdentityInfo();
374 CJson *credAuthInfo = CreateJson();
375 CJson *context = CreateJson();
376 int32_t ret = ISSetCertInfoAndEntity(TEST_OS_ACCOUNT_ID, context, credAuthInfo, true, info);
377 EXPECT_NE(ret, HC_SUCCESS);
378 (void)AddStringToJson(credAuthInfo, FIELD_DEVICE_ID, TEST_DEVICE_ID);
379 ret = ISSetCertInfoAndEntity(TEST_OS_ACCOUNT_ID, context, credAuthInfo, true, info);
380 EXPECT_NE(ret, HC_SUCCESS);
381 (void)AddStringToJson(credAuthInfo, FIELD_USER_ID, TEST_USER_ID);
382 ret = ISSetCertInfoAndEntity(TEST_OS_ACCOUNT_ID, context, credAuthInfo, true, info);
383 EXPECT_NE(ret, HC_SUCCESS);
384 FreeJson(context);
385 FreeJson(credAuthInfo);
386 DestroyIdentityInfo(info);
387 }
388
389 HWTEST_F(IdentityCredTest, IdentityCredTest007, TestSize.Level0)
390 {
391 IdentityInfo *info = CreateIdentityInfo();
392 CJson *credAuthInfo = CreateJson();
393 int32_t ret = ISSetPreShareUrlAndEntity(credAuthInfo, info);
394 EXPECT_NE(ret, HC_SUCCESS);
395 (void)AddIntToJson(credAuthInfo, FIELD_CRED_TYPE, ACCOUNT_UNRELATED);
396 ret = ISSetPreShareUrlAndEntity(credAuthInfo, info);
397 EXPECT_NE(ret, HC_SUCCESS);
398 (void)AddIntToJson(credAuthInfo, FIELD_KEY_FORMAT, SYMMETRIC_KEY);
399 ret = ISSetPreShareUrlAndEntity(credAuthInfo, info);
400 EXPECT_EQ(ret, HC_SUCCESS);
401 (void)AddIntToJson(credAuthInfo, FIELD_KEY_FORMAT, ASYMMETRIC_KEY);
402 ret = ISSetPreShareUrlAndEntity(credAuthInfo, info);
403 EXPECT_EQ(ret, HC_SUCCESS);
404 (void)AddIntToJson(credAuthInfo, FIELD_KEY_FORMAT, ASYMMETRIC_PUB_KEY);
405 ret = ISSetPreShareUrlAndEntity(credAuthInfo, info);
406 EXPECT_EQ(ret, HC_SUCCESS);
407 FreeJson(credAuthInfo);
408 DestroyIdentityInfo(info);
409 }
410
411 HWTEST_F(IdentityCredTest, IdentityCredTest008, TestSize.Level0)
412 {
413 IdentityInfo *info = CreateIdentityInfo();
414 CJson *credAuthInfo = CreateJson();
415 CJson *context = CreateJson();
416 info->proofType = (IdentityProofType)UNSUPPORTED_PROOF_TYPE;
417 int32_t ret = ISSetCertProofAndEntity(context, credAuthInfo, true, info);
418 EXPECT_NE(ret, HC_SUCCESS);
419 info->proofType = PRE_SHARED;
420 ret = ISSetCertProofAndEntity(context, credAuthInfo, true, info);
421 EXPECT_NE(ret, HC_SUCCESS);
422 info->proofType = CERTIFICATED;
423 ret = ISSetCertProofAndEntity(context, credAuthInfo, true, info);
424 EXPECT_NE(ret, HC_SUCCESS);
425 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
426 ret = ISSetCertProofAndEntity(context, credAuthInfo, true, info);
427 EXPECT_NE(ret, HC_SUCCESS);
428 FreeJson(context);
429 FreeJson(credAuthInfo);
430 DestroyIdentityInfo(info);
431 }
432
433 HWTEST_F(IdentityCredTest, IdentityCredTest009, TestSize.Level0)
434 {
435 IdentityInfo *info = CreateIdentityInfo();
436 CJson *credAuthInfo = CreateJson();
437 CJson *context = CreateJson();
438 int32_t ret = ISGetIdentityInfo(context, true, &info);
439 EXPECT_NE(ret, HC_SUCCESS);
440 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
441 ret = ISGetIdentityInfo(context, true, &info);
442 EXPECT_NE(ret, HC_SUCCESS);
443 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PSK);
444 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
445 ret = ISGetIdentityInfo(context, true, &info);
446 EXPECT_EQ(ret, HC_SUCCESS);
447 ret = ISGetIdentityInfo(context, false, &info);
448 EXPECT_NE(ret, HC_SUCCESS);
449 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PKI);
450 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
451 ret = ISGetIdentityInfo(context, false, &info);
452 EXPECT_NE(ret, HC_SUCCESS);
453 FreeJson(context);
454 FreeJson(credAuthInfo);
455 DestroyIdentityInfo(info);
456 }
457
458 HWTEST_F(IdentityCredTest, IdentityCredTest010, TestSize.Level0)
459 {
460 IdentityInfoVec vec = CreateIdentityInfoVec();
461 CJson *context = CreateJson();
462 CJson *credAuthInfo = CreateJson();
463 int32_t ret = AddIdentityInfoToVec(context, false, &vec);
464 EXPECT_NE(ret, HC_SUCCESS);
465 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PSK);
466 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
467 ret = AddIdentityInfoToVec(context, true, &vec);
468 EXPECT_EQ(ret, HC_SUCCESS);
469 FreeJson(credAuthInfo);
470 FreeJson(context);
471 ClearIdentityInfoVec(&vec);
472 }
473
474 HWTEST_F(IdentityCredTest, IdentityCredTest011, TestSize.Level0)
475 {
476 IdentityInfoVec vec = CreateIdentityInfoVec();
477 CJson *context = CreateJson();
478 CJson *credAuthInfo = CreateJson();
479 int32_t ret = GetCredInfosByPeerIdentity(nullptr, &vec);
480 EXPECT_NE(ret, HC_SUCCESS);
481 ret = GetCredInfosByPeerIdentity(context, nullptr);
482 EXPECT_NE(ret, HC_SUCCESS);
483 ret = GetCredInfosByPeerIdentity(nullptr, nullptr);
484 EXPECT_NE(ret, HC_SUCCESS);
485 ret = GetCredInfosByPeerIdentity(context, &vec);
486 EXPECT_NE(ret, HC_SUCCESS);
487 FreeJson(credAuthInfo);
488 FreeJson(context);
489 ClearIdentityInfoVec(&vec);
490 }
491
492 HWTEST_F(IdentityCredTest, IdentityCredTest012, TestSize.Level0)
493 {
494 IdentityInfo *info = CreateIdentityInfo();
495 CJson *context = CreateJson();
496 Uint8Buff presharedUrl = {nullptr, 0};
497 int32_t ret = GetCredInfoByPeerUrl(nullptr, &presharedUrl, &info);
498 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
499 ret = GetCredInfoByPeerUrl(context, nullptr, &info);
500 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
501 ret = GetCredInfoByPeerUrl(context, &presharedUrl, nullptr);
502 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
503 ret = GetCredInfoByPeerUrl(context, &presharedUrl, &info);
504 EXPECT_NE(ret, HC_SUCCESS);
505 ret = GetCredInfoByPeerUrl(nullptr, nullptr, nullptr);
506 EXPECT_NE(ret, HC_SUCCESS);
507 FreeJson(context);
508 DestroyIdentityInfo(info);
509 }
510
511 HWTEST_F(IdentityCredTest, IdentityCredTest013, TestSize.Level0)
512 {
513 CJson *context = CreateJson();
514 Uint8Buff credIdByte = {nullptr, 0};
515 Uint8Buff sharedSecret = {nullptr, 0};
516 int32_t ret = ComputeHkdfKeyAlias(context, TEST_OS_ACCOUNT_ID, &credIdByte, &sharedSecret);
517 EXPECT_NE(ret, HC_SUCCESS);
518 AddByteToJson(context, FIELD_NONCE, reinterpret_cast<const uint8_t *>(TEST_BYTE), HcStrlen(TEST_BYTE));
519 ret = ComputeHkdfKeyAlias(context, TEST_OS_ACCOUNT_ID, &credIdByte, &sharedSecret);
520 EXPECT_NE(ret, HC_SUCCESS);
521 FreeJson(context);
522 }
523
524 HWTEST_F(IdentityCredTest, IdentityCredTest014, TestSize.Level0)
525 {
526 CJson *context = CreateJson();
527 Uint8Buff keyAlias = {nullptr, 0};
528 Uint8Buff authToken = {nullptr, 0};
529 int32_t ret = ComputeAuthToken(TEST_OS_ACCOUNT_ID, TEST_USER_ID, keyAlias, &authToken);
530 EXPECT_NE(ret, HC_SUCCESS);
531 FreeJson(context);
532 }
533
534 HWTEST_F(IdentityCredTest, IdentityCredTest015, TestSize.Level0)
535 {
536 CJson *context = CreateJson();
537 Uint8Buff authToken = {nullptr, 0};
538 int32_t ret = GenerateAuthTokenForAccessory(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, context, &authToken);
539 EXPECT_NE(ret, HC_SUCCESS);
540 (void)AddStringToJson(context, FIELD_USER_ID, TEST_USER_ID);
541 ret = GenerateAuthTokenForAccessory(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, context, &authToken);
542 EXPECT_NE(ret, HC_SUCCESS);
543 FreeJson(context);
544 }
545
546 HWTEST_F(IdentityCredTest, IdentityCredTest016, TestSize.Level0)
547 {
548 Uint8Buff authToken = {nullptr, 0};
549 int32_t ret = GenerateTokenAliasForController(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, &authToken);
550 EXPECT_NE(ret, HC_SUCCESS);
551 }
552
553 HWTEST_F(IdentityCredTest, IdentityCredTest017, TestSize.Level0)
554 {
555 CJson *context = CreateJson();
556 CJson *credAuthInfo = CreateJson();
557 Uint8Buff authToken = {nullptr, 0};
558 bool isTokenStored = true;
559 int32_t ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
560 EXPECT_NE(ret, HC_SUCCESS);
561 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
562 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
563 EXPECT_NE(ret, HC_SUCCESS);
564 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
565 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
566 EXPECT_NE(ret, HC_SUCCESS);
567 (void)AddIntToJson(credAuthInfo, FIELD_SUBJECT, SUBJECT_ACCESSORY_DEVICE);
568 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
569 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
570 EXPECT_NE(ret, HC_SUCCESS);
571 (void)AddIntToJson(credAuthInfo, FIELD_SUBJECT, SUBJECT_MASTER_CONTROLLER);
572 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
573 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
574 EXPECT_NE(ret, HC_SUCCESS);
575 FreeJson(credAuthInfo);
576 FreeJson(context);
577 }
578
579 HWTEST_F(IdentityCredTest, IdentityCredTest018, TestSize.Level0)
580 {
581 CJson *context = CreateJson();
582 int32_t ret = ISGetAccountSymSharedSecret(context, nullptr);
583 EXPECT_NE(ret, HC_SUCCESS);
584 ret = ISGetAccountSymSharedSecret(nullptr, nullptr);
585 EXPECT_NE(ret, HC_SUCCESS);
586 Uint8Buff sharedSecret = {nullptr, 0};
587 ret = ISGetAccountSymSharedSecret(context, &sharedSecret);
588 EXPECT_NE(ret, HC_SUCCESS);
589 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
590 ret = ISGetAccountSymSharedSecret(context, &sharedSecret);
591 EXPECT_NE(ret, HC_SUCCESS);
592 FreeJson(context);
593 }
594
595 HWTEST_F(IdentityCredTest, IdentityCredTest019, TestSize.Level0)
596 {
597 CJson *context = CreateJson();
598 int32_t ret = AuthGeneratePsk(nullptr, nullptr, nullptr);
599 EXPECT_NE(ret, HC_SUCCESS);
600 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
601 ret = AuthGeneratePsk(context, nullptr, nullptr);
602 EXPECT_NE(ret, HC_SUCCESS);
603 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
604 ret = AuthGeneratePsk(context, nullptr, nullptr);
605 EXPECT_NE(ret, HC_SUCCESS);
606 FreeJson(context);
607 }
608
609 HWTEST_F(IdentityCredTest, IdentityCredTest020, TestSize.Level0)
610 {
611 int32_t ret = GetSharedSecretForP2pInIso(nullptr, nullptr);
612 EXPECT_NE(ret, HC_SUCCESS);
613 }
614
615 HWTEST_F(IdentityCredTest, IdentityCredTest021, TestSize.Level0)
616 {
617 int32_t ret = GetSharedSecretForP2pInPake(nullptr, nullptr);
618 EXPECT_NE(ret, HC_SUCCESS);
619 CJson *context = CreateJson();
620 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
621 ret = GetSharedSecretForP2pInPake(context, nullptr);
622 EXPECT_NE(ret, HC_SUCCESS);
623 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
624 ret = GetSharedSecretForP2pInPake(context, nullptr);
625 EXPECT_NE(ret, HC_SUCCESS);
626 FreeJson(context);
627 }
628
629 HWTEST_F(IdentityCredTest, IdentityCredTest022, TestSize.Level0)
630 {
631 Uint8Buff sharedSecret = {nullptr, 0};
632 int32_t ret = GetSharedSecretForP2p(nullptr, ALG_EC_SPEKE, &sharedSecret);
633 EXPECT_NE(ret, HC_SUCCESS);
634 ret = GetSharedSecretForP2p(nullptr, ALG_ISO, &sharedSecret);
635 EXPECT_NE(ret, HC_SUCCESS);
636 }
637
638 HWTEST_F(IdentityCredTest, IdentityCredTest023, TestSize.Level0)
639 {
640 Uint8Buff sharedSecret = {nullptr, 0};
641 int32_t ret = GetSharedSecretForUid(nullptr, ALG_EC_SPEKE, &sharedSecret);
642 EXPECT_NE(ret, HC_SUCCESS);
643 ret = GetSharedSecretForUid(nullptr, ALG_ISO, &sharedSecret);
644 EXPECT_NE(ret, HC_SUCCESS);
645 }
646
647 HWTEST_F(IdentityCredTest, IdentityCredTest024, TestSize.Level0)
648 {
649 CJson *context = CreateJson();
650 Uint8Buff sharedSecret = {nullptr, 0};
651 Uint8Buff presharedUrl = {nullptr, 0};
652 int32_t ret = GetSharedSecretByUrl(nullptr, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
653 EXPECT_NE(ret, HC_SUCCESS);
654 ret = GetSharedSecretByUrl(context, nullptr, ALG_EC_SPEKE, &sharedSecret);
655 EXPECT_NE(ret, HC_SUCCESS);
656 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, nullptr);
657 EXPECT_NE(ret, HC_SUCCESS);
658 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
659 EXPECT_NE(ret, HC_SUCCESS);
660 char *urlStr = nullptr;
661 (void)CreateUrlStr(ACCOUNT_RELATED, KEY_TYPE_SYM, &urlStr);
662 SetPreSharedUrlForProof(urlStr, &presharedUrl);
663 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
664 EXPECT_NE(ret, HC_SUCCESS);
665 FreeJsonString(urlStr);
666 urlStr = nullptr;
667 (void)CreateUrlStr(ACCOUNT_UNRELATED, KEY_TYPE_SYM, &urlStr);
668 SetPreSharedUrlForProof(urlStr, &presharedUrl);
669 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
670 EXPECT_NE(ret, HC_SUCCESS);
671 FreeJsonString(urlStr);
672 FreeJson(context);
673 }
674
675 HWTEST_F(IdentityCredTest, IdentityCredTest025, TestSize.Level0)
676 {
677 CJson *context = CreateJson();
678 int32_t ret = GetCredInfoByPeerCert(nullptr, nullptr, nullptr);
679 EXPECT_NE(ret, HC_SUCCESS);
680 ret = GetCredInfoByPeerCert(context, nullptr, nullptr);
681 EXPECT_NE(ret, HC_SUCCESS);
682 CertInfo certInfo = {{nullptr, 0}, {nullptr, 0}, P256, false};
683 ret = GetCredInfoByPeerCert(context, &certInfo, nullptr);
684 EXPECT_NE(ret, HC_SUCCESS);
685 FreeJson(context);
686 }
687
688 HWTEST_F(IdentityCredTest, IdentityCredTest026, TestSize.Level0)
689 {
690 CertInfo certInfo = {{nullptr, 0}, {nullptr, 0}, P256, false};
691 Uint8Buff sharedSecret = {nullptr, 0};
692 CJson *context = CreateJson();
693 int32_t ret = GetSharedSecretByPeerCert(nullptr, &certInfo, ALG_ISO, &sharedSecret);
694 EXPECT_NE(ret, HC_SUCCESS);
695 ret = GetSharedSecretByPeerCert(context, nullptr, ALG_ISO, &sharedSecret);
696 EXPECT_NE(ret, HC_SUCCESS);
697 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_ISO, nullptr);
698 EXPECT_NE(ret, HC_SUCCESS);
699 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_ISO, &sharedSecret);
700 EXPECT_NE(ret, HC_SUCCESS);
701 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
702 EXPECT_NE(ret, HC_SUCCESS);
703 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
704 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
705 EXPECT_NE(ret, HC_SUCCESS);
706 (void)AddStringToJson(context, FIELD_ACROSS_ACCOUNT_CRED_ID, TEST_CRED_ID);
707 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
708 EXPECT_NE(ret, HC_SUCCESS);
709 FreeJson(context);
710 }
711 }