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 "base/security/device_auth/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, FIELD_PEER_USER_ID, nullptr, nullptr);
131 EXPECT_NE(ret, HC_SUCCESS);
132 CertInfo peerCertInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
133 ret = GetAccountAsymSharedSecret(TEST_OS_ACCOUNT_ID, nullptr, FIELD_PEER_USER_ID, &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 AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
417 info->proofType = (IdentityProofType)UNSUPPORTED_PROOF_TYPE;
418 int32_t ret = ISSetCertProofAndEntity(context, true, info);
419 EXPECT_NE(ret, HC_SUCCESS);
420 info->proofType = PRE_SHARED;
421 ret = ISSetCertProofAndEntity(context, true, info);
422 EXPECT_NE(ret, HC_SUCCESS);
423 info->proofType = CERTIFICATED;
424 ret = ISSetCertProofAndEntity(context, true, info);
425 EXPECT_NE(ret, HC_SUCCESS);
426 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
427 ret = ISSetCertProofAndEntity(context, true, info);
428 EXPECT_NE(ret, HC_SUCCESS);
429 FreeJson(context);
430 FreeJson(credAuthInfo);
431 DestroyIdentityInfo(info);
432 }
433
434 HWTEST_F(IdentityCredTest, IdentityCredTest009, TestSize.Level0)
435 {
436 IdentityInfo *info = CreateIdentityInfo();
437 CJson *credAuthInfo = CreateJson();
438 CJson *context = CreateJson();
439 int32_t ret = ISGetIdentityInfo(context, true, &info);
440 EXPECT_NE(ret, HC_SUCCESS);
441 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
442 ret = ISGetIdentityInfo(context, true, &info);
443 EXPECT_NE(ret, HC_SUCCESS);
444 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PSK);
445 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
446 ret = ISGetIdentityInfo(context, true, &info);
447 EXPECT_EQ(ret, HC_SUCCESS);
448 ret = ISGetIdentityInfo(context, false, &info);
449 EXPECT_NE(ret, HC_SUCCESS);
450 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PKI);
451 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
452 ret = ISGetIdentityInfo(context, false, &info);
453 EXPECT_NE(ret, HC_SUCCESS);
454 FreeJson(context);
455 FreeJson(credAuthInfo);
456 DestroyIdentityInfo(info);
457 }
458
459 HWTEST_F(IdentityCredTest, IdentityCredTest010, TestSize.Level0)
460 {
461 IdentityInfoVec vec = CreateIdentityInfoVec();
462 CJson *context = CreateJson();
463 CJson *credAuthInfo = CreateJson();
464 int32_t ret = AddIdentityInfoToVec(context, false, &vec);
465 EXPECT_NE(ret, HC_SUCCESS);
466 (void)AddIntToJson(credAuthInfo, FIELD_PROOF_TYPE, PROOF_TYPE_PSK);
467 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
468 ret = AddIdentityInfoToVec(context, true, &vec);
469 EXPECT_EQ(ret, HC_SUCCESS);
470 FreeJson(credAuthInfo);
471 FreeJson(context);
472 ClearIdentityInfoVec(&vec);
473 }
474
475 HWTEST_F(IdentityCredTest, IdentityCredTest011, TestSize.Level0)
476 {
477 IdentityInfoVec vec = CreateIdentityInfoVec();
478 CJson *context = CreateJson();
479 CJson *credAuthInfo = CreateJson();
480 int32_t ret = GetCredInfosByPeerIdentity(nullptr, &vec);
481 EXPECT_NE(ret, HC_SUCCESS);
482 ret = GetCredInfosByPeerIdentity(context, nullptr);
483 EXPECT_NE(ret, HC_SUCCESS);
484 ret = GetCredInfosByPeerIdentity(nullptr, nullptr);
485 EXPECT_NE(ret, HC_SUCCESS);
486 ret = GetCredInfosByPeerIdentity(context, &vec);
487 EXPECT_NE(ret, HC_SUCCESS);
488 FreeJson(credAuthInfo);
489 FreeJson(context);
490 ClearIdentityInfoVec(&vec);
491 }
492
493 HWTEST_F(IdentityCredTest, IdentityCredTest012, TestSize.Level0)
494 {
495 IdentityInfo *info = CreateIdentityInfo();
496 CJson *context = CreateJson();
497 Uint8Buff presharedUrl = {nullptr, 0};
498 int32_t ret = GetCredInfoByPeerUrl(nullptr, &presharedUrl, &info);
499 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
500 ret = GetCredInfoByPeerUrl(context, nullptr, &info);
501 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
502 ret = GetCredInfoByPeerUrl(context, &presharedUrl, nullptr);
503 EXPECT_EQ(ret, HC_ERR_INVALID_PARAMS);
504 ret = GetCredInfoByPeerUrl(context, &presharedUrl, &info);
505 EXPECT_NE(ret, HC_SUCCESS);
506 ret = GetCredInfoByPeerUrl(nullptr, nullptr, nullptr);
507 EXPECT_NE(ret, HC_SUCCESS);
508 FreeJson(context);
509 DestroyIdentityInfo(info);
510 }
511
512 HWTEST_F(IdentityCredTest, IdentityCredTest013, TestSize.Level0)
513 {
514 CJson *context = CreateJson();
515 Uint8Buff credIdByte = {nullptr, 0};
516 Uint8Buff sharedSecret = {nullptr, 0};
517 int32_t ret = ComputeHkdfKeyAlias(context, TEST_OS_ACCOUNT_ID, &credIdByte, &sharedSecret);
518 EXPECT_NE(ret, HC_SUCCESS);
519 AddByteToJson(context, FIELD_NONCE, reinterpret_cast<const uint8_t *>(TEST_BYTE), HcStrlen(TEST_BYTE));
520 ret = ComputeHkdfKeyAlias(context, TEST_OS_ACCOUNT_ID, &credIdByte, &sharedSecret);
521 EXPECT_NE(ret, HC_SUCCESS);
522 FreeJson(context);
523 }
524
525 HWTEST_F(IdentityCredTest, IdentityCredTest014, TestSize.Level0)
526 {
527 CJson *context = CreateJson();
528 Uint8Buff keyAlias = {nullptr, 0};
529 Uint8Buff authToken = {nullptr, 0};
530 int32_t ret = ComputeAuthToken(TEST_OS_ACCOUNT_ID, TEST_USER_ID, keyAlias, &authToken);
531 EXPECT_NE(ret, HC_SUCCESS);
532 FreeJson(context);
533 }
534
535 HWTEST_F(IdentityCredTest, IdentityCredTest015, TestSize.Level0)
536 {
537 CJson *context = CreateJson();
538 Uint8Buff authToken = {nullptr, 0};
539 int32_t ret = GenerateAuthTokenForAccessory(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, context, &authToken);
540 EXPECT_NE(ret, HC_SUCCESS);
541 (void)AddStringToJson(context, FIELD_USER_ID, TEST_USER_ID);
542 ret = GenerateAuthTokenForAccessory(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, context, &authToken);
543 EXPECT_NE(ret, HC_SUCCESS);
544 FreeJson(context);
545 }
546
547 HWTEST_F(IdentityCredTest, IdentityCredTest016, TestSize.Level0)
548 {
549 Uint8Buff authToken = {nullptr, 0};
550 int32_t ret = GenerateTokenAliasForController(TEST_OS_ACCOUNT_ID, TEST_CRED_ID, &authToken);
551 EXPECT_NE(ret, HC_SUCCESS);
552 }
553
554 HWTEST_F(IdentityCredTest, IdentityCredTest017, TestSize.Level0)
555 {
556 CJson *context = CreateJson();
557 CJson *credAuthInfo = CreateJson();
558 Uint8Buff authToken = {nullptr, 0};
559 bool isTokenStored = true;
560 int32_t ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
561 EXPECT_NE(ret, HC_SUCCESS);
562 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
563 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
564 EXPECT_NE(ret, HC_SUCCESS);
565 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
566 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
567 EXPECT_NE(ret, HC_SUCCESS);
568 (void)AddIntToJson(credAuthInfo, FIELD_SUBJECT, SUBJECT_ACCESSORY_DEVICE);
569 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
570 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
571 EXPECT_NE(ret, HC_SUCCESS);
572 (void)AddIntToJson(credAuthInfo, FIELD_SUBJECT, SUBJECT_MASTER_CONTROLLER);
573 (void)AddObjToJson(context, FIELD_CREDENTIAL_OBJ, credAuthInfo);
574 ret = GenerateAuthTokenByDevType(TEST_OS_ACCOUNT_ID, context, &authToken, &isTokenStored);
575 EXPECT_NE(ret, HC_SUCCESS);
576 FreeJson(credAuthInfo);
577 FreeJson(context);
578 }
579
580 HWTEST_F(IdentityCredTest, IdentityCredTest018, TestSize.Level0)
581 {
582 CJson *context = CreateJson();
583 int32_t ret = ISGetAccountSymSharedSecret(context, nullptr);
584 EXPECT_NE(ret, HC_SUCCESS);
585 ret = ISGetAccountSymSharedSecret(nullptr, nullptr);
586 EXPECT_NE(ret, HC_SUCCESS);
587 Uint8Buff sharedSecret = {nullptr, 0};
588 ret = ISGetAccountSymSharedSecret(context, &sharedSecret);
589 EXPECT_NE(ret, HC_SUCCESS);
590 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
591 ret = ISGetAccountSymSharedSecret(context, &sharedSecret);
592 EXPECT_NE(ret, HC_SUCCESS);
593 FreeJson(context);
594 }
595
596 HWTEST_F(IdentityCredTest, IdentityCredTest019, TestSize.Level0)
597 {
598 CJson *context = CreateJson();
599 int32_t ret = AuthGeneratePsk(nullptr, nullptr, nullptr);
600 EXPECT_NE(ret, HC_SUCCESS);
601 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
602 ret = AuthGeneratePsk(context, nullptr, nullptr);
603 EXPECT_NE(ret, HC_SUCCESS);
604 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
605 ret = AuthGeneratePsk(context, nullptr, nullptr);
606 EXPECT_NE(ret, HC_SUCCESS);
607 FreeJson(context);
608 }
609
610 HWTEST_F(IdentityCredTest, IdentityCredTest020, TestSize.Level0)
611 {
612 int32_t ret = GetSharedSecretForP2pInIso(nullptr, nullptr);
613 EXPECT_NE(ret, HC_SUCCESS);
614 }
615
616 HWTEST_F(IdentityCredTest, IdentityCredTest021, TestSize.Level0)
617 {
618 int32_t ret = GetSharedSecretForP2pInPake(nullptr, nullptr);
619 EXPECT_NE(ret, HC_SUCCESS);
620 CJson *context = CreateJson();
621 (void)AddStringToJson(context, FIELD_CRED_ID, TEST_CRED_ID);
622 ret = GetSharedSecretForP2pInPake(context, nullptr);
623 EXPECT_NE(ret, HC_SUCCESS);
624 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
625 ret = GetSharedSecretForP2pInPake(context, nullptr);
626 EXPECT_NE(ret, HC_SUCCESS);
627 FreeJson(context);
628 }
629
630 HWTEST_F(IdentityCredTest, IdentityCredTest022, TestSize.Level0)
631 {
632 Uint8Buff sharedSecret = {nullptr, 0};
633 int32_t ret = GetSharedSecretForP2p(nullptr, ALG_EC_SPEKE, &sharedSecret);
634 EXPECT_NE(ret, HC_SUCCESS);
635 ret = GetSharedSecretForP2p(nullptr, ALG_ISO, &sharedSecret);
636 EXPECT_NE(ret, HC_SUCCESS);
637 }
638
639 HWTEST_F(IdentityCredTest, IdentityCredTest023, TestSize.Level0)
640 {
641 Uint8Buff sharedSecret = {nullptr, 0};
642 int32_t ret = GetSharedSecretForUid(nullptr, ALG_EC_SPEKE, &sharedSecret);
643 EXPECT_NE(ret, HC_SUCCESS);
644 ret = GetSharedSecretForUid(nullptr, ALG_ISO, &sharedSecret);
645 EXPECT_NE(ret, HC_SUCCESS);
646 }
647
648 HWTEST_F(IdentityCredTest, IdentityCredTest024, TestSize.Level0)
649 {
650 CJson *context = CreateJson();
651 Uint8Buff sharedSecret = {nullptr, 0};
652 Uint8Buff presharedUrl = {nullptr, 0};
653 int32_t ret = GetSharedSecretByUrl(nullptr, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
654 EXPECT_NE(ret, HC_SUCCESS);
655 ret = GetSharedSecretByUrl(context, nullptr, ALG_EC_SPEKE, &sharedSecret);
656 EXPECT_NE(ret, HC_SUCCESS);
657 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, nullptr);
658 EXPECT_NE(ret, HC_SUCCESS);
659 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
660 EXPECT_NE(ret, HC_SUCCESS);
661 char *urlStr = nullptr;
662 (void)CreateUrlStr(ACCOUNT_RELATED, KEY_TYPE_SYM, &urlStr);
663 SetPreSharedUrlForProof(urlStr, &presharedUrl);
664 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
665 EXPECT_NE(ret, HC_SUCCESS);
666 FreeJsonString(urlStr);
667 urlStr = nullptr;
668 (void)CreateUrlStr(ACCOUNT_UNRELATED, KEY_TYPE_SYM, &urlStr);
669 SetPreSharedUrlForProof(urlStr, &presharedUrl);
670 ret = GetSharedSecretByUrl(context, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
671 EXPECT_NE(ret, HC_SUCCESS);
672 FreeJsonString(urlStr);
673 FreeJson(context);
674 }
675
676 HWTEST_F(IdentityCredTest, IdentityCredTest025, TestSize.Level0)
677 {
678 CJson *context = CreateJson();
679 int32_t ret = GetCredInfoByPeerCert(nullptr, nullptr, nullptr);
680 EXPECT_NE(ret, HC_SUCCESS);
681 ret = GetCredInfoByPeerCert(context, nullptr, nullptr);
682 EXPECT_NE(ret, HC_SUCCESS);
683 CertInfo certInfo = {{nullptr, 0}, {nullptr, 0}, P256, false};
684 ret = GetCredInfoByPeerCert(context, &certInfo, nullptr);
685 EXPECT_NE(ret, HC_SUCCESS);
686 FreeJson(context);
687 }
688
689 HWTEST_F(IdentityCredTest, IdentityCredTest026, TestSize.Level0)
690 {
691 CertInfo certInfo = {{nullptr, 0}, {nullptr, 0}, P256, false};
692 Uint8Buff sharedSecret = {nullptr, 0};
693 CJson *context = CreateJson();
694 int32_t ret = GetSharedSecretByPeerCert(nullptr, &certInfo, ALG_ISO, &sharedSecret);
695 EXPECT_NE(ret, HC_SUCCESS);
696 ret = GetSharedSecretByPeerCert(context, nullptr, ALG_ISO, &sharedSecret);
697 EXPECT_NE(ret, HC_SUCCESS);
698 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_ISO, nullptr);
699 EXPECT_NE(ret, HC_SUCCESS);
700 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_ISO, &sharedSecret);
701 EXPECT_NE(ret, HC_SUCCESS);
702 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
703 EXPECT_NE(ret, HC_SUCCESS);
704 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
705 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
706 EXPECT_NE(ret, HC_SUCCESS);
707 (void)AddStringToJson(context, FIELD_ACROSS_ACCOUNT_CRED_ID, TEST_CRED_ID);
708 ret = GetSharedSecretByPeerCert(context, &certInfo, ALG_EC_SPEKE, &sharedSecret);
709 EXPECT_NE(ret, HC_SUCCESS);
710 FreeJson(context);
711 }
712 }