1 /*
2  * Copyright (c) 2023 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 "credsmanager_fuzzer.h"
17 
18 #include <ctime>
19 #include <unistd.h>
20 #include "account_module_defines.h"
21 #include "alg_loader.h"
22 #include "asy_token_manager.h"
23 #include "common_defs.h"
24 #include "creds_manager.h"
25 #include "device_auth.h"
26 #include "device_auth_defines.h"
27 #include "hc_dev_info_mock.h"
28 #include "hc_log.h"
29 #include "json_utils.h"
30 #include "securec.h"
31 
32 namespace OHOS {
33 static const std::string TEST_PIN_CODE = "123456";
34 static const std::string TEST_APP_ID = "TestAppId";
35 static const std::string TEST_APP_ID2 = "TestAppId2";
36 static const std::string TEST_AUTH_ID = "TestAuthId";
37 static const std::string TEST_AUTH_ID2 = "TestAuthId2";
38 static const std::string TEST_UDID_CLIENT = "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930";
39 static const std::string TEST_UDID_SERVER = "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C";
40 static const std::string TEST_CREATE_PARAMS = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"group"
41     "Type\":256,\"groupVisibility\":-1,\"userType\":0,\"expireTime\":-1}";
42 static const std::string TEST_CREATE_PARAMS2 = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"group"
43     "Type\":256,\"groupVisibility\":0,\"userType\":0,\"expireTime\":-1}";
44 static const std::string TEST_ADD_PARAMS =
45     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
46     "\"groupType\":256,\"pinCode\":\"123456\"}";
47 static const std::string TEST_GROUP_ID = "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21";
48 static const std::string TEST_USER_ID = "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4";
49 static const std::string TEST_REGISTER_INFO_PARAM =
50     "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\",\"userId\":"
51     "\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
52 static const std::string TEST_REGISTER_INFO_PARAM2 =
53     "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId2\",\"userId\":"
54     "\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
55 static const std::string TEST_ADD_MULTI_PARAM =
56     "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\",\"deviceList\":"
57     "[{\"deviceId\":\"TestAuthId2\",\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\","
58     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\",\"credential\":{\"credentialType"
59     "\":1,\"authCode\":\"10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92\"}}]}";
60 static const std::string TEST_AUTH_PARAMS = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
61     "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
62 static const std::string TEST_AUTH_CODE = "1234123412341234123412341234123412341234123412341234123412341234";
63 static const std::string TEST_GROUP_DATA_PATH = "/data/service/el1/public/deviceauthMock";
64 static const std::string TEST_HKS_MAIN_DATA_PATH = "/data/service/el1/public/huks_service/tmp/+0+0+0+0";
65 
66 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
67 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
68 static const int64_t TEST_REQ_ID = 123;
69 static const int64_t TEST_REQ_ID2 = 321;
70 static const uint32_t TEST_DEV_AUTH_SLEEP_TIME = 50000;
71 static const uint32_t TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN = 32;
72 
73 enum AsyncStatus {
74     ASYNC_STATUS_WAITING = 0,
75     ASYNC_STATUS_TRANSMIT = 1,
76     ASYNC_STATUS_FINISH = 2,
77     ASYNC_STATUS_ERROR = 3
78 };
79 
80 static AsyncStatus volatile g_asyncStatus;
81 static uint8_t g_transmitData[2048] = { 0 };
82 static uint32_t g_transmitDataLen = 0;
83 
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)84 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
85 {
86     if (memcpy_s(g_transmitData, sizeof(g_transmitData), data, dataLen) != EOK) {
87         return false;
88     }
89     g_transmitDataLen = dataLen;
90     g_asyncStatus = ASYNC_STATUS_TRANSMIT;
91     return true;
92 }
93 
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)94 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
95 {
96     (void)requestId;
97     (void)sessionKey;
98     (void)sessionKeyLen;
99 }
100 
OnFinish(int64_t requestId,int operationCode,const char * authReturn)101 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
102 {
103     (void)requestId;
104     (void)operationCode;
105     (void)authReturn;
106     g_asyncStatus = ASYNC_STATUS_FINISH;
107 }
108 
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)109 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
110 {
111     (void)requestId;
112     (void)operationCode;
113     (void)errorCode;
114     (void)errorReturn;
115     g_asyncStatus = ASYNC_STATUS_ERROR;
116 }
117 
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)118 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
119 {
120     (void)requestId;
121     (void)operationCode;
122     (void)reqParam;
123     CJson *json = CreateJson();
124     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
125     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
126     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
127     AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2.c_str());
128     char *returnDataStr = PackJsonToString(json);
129     FreeJson(json);
130     return returnDataStr;
131 }
132 
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)133 static char *OnAuthRequest(int64_t requestId, int operationCode, const char* reqParam)
134 {
135     CJson *json = CreateJson();
136     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
137     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
138     AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT.c_str());
139     AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
140     char *returnDataStr = PackJsonToString(json);
141     FreeJson(json);
142     return returnDataStr;
143 }
144 
145 static DeviceAuthCallback g_gmCallback = {
146     .onTransmit = OnTransmit,
147     .onSessionKeyReturned = OnSessionKeyReturned,
148     .onFinish = OnFinish,
149     .onError = OnError,
150     .onRequest = OnBindRequest
151 };
152 
153 static DeviceAuthCallback g_gaCallback = {
154     .onTransmit = OnTransmit,
155     .onSessionKeyReturned = OnSessionKeyReturned,
156     .onFinish = OnFinish,
157     .onError = OnError,
158     .onRequest = OnAuthRequest
159 };
160 
RemoveDir(const char * path)161 static void RemoveDir(const char *path)
162 {
163     char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = { 0 };
164     if (path == nullptr) {
165         return;
166     }
167     if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
168         return;
169     }
170     system(strBuf);
171 }
172 
DeleteDatabase()173 static void DeleteDatabase()
174 {
175     RemoveDir(TEST_GROUP_DATA_PATH.c_str());
176     RemoveDir(TEST_HKS_MAIN_DATA_PATH.c_str());
177 }
178 
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)179 static void CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
180 {
181     g_asyncStatus = ASYNC_STATUS_WAITING;
182     const DeviceGroupManager *gm = GetGmInstance();
183     int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
184     if (ret != HC_SUCCESS) {
185         g_asyncStatus = ASYNC_STATUS_ERROR;
186         return;
187     }
188     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
189         usleep(TEST_DEV_AUTH_SLEEP_TIME);
190     }
191 }
192 
AddDemoMember(void)193 static void AddDemoMember(void)
194 {
195     g_asyncStatus = ASYNC_STATUS_WAITING;
196     bool isClient = true;
197     SetDeviceStatus(isClient);
198     const DeviceGroupManager *gm = GetGmInstance();
199     int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_ADD_PARAMS.c_str());
200     if (ret != HC_SUCCESS) {
201         g_asyncStatus = ASYNC_STATUS_ERROR;
202         return;
203     }
204     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
205         usleep(TEST_DEV_AUTH_SLEEP_TIME);
206     }
207     while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
208         isClient = !isClient;
209         SetDeviceStatus(isClient);
210         g_asyncStatus = ASYNC_STATUS_WAITING;
211         if (isClient) {
212             ret = gm->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen);
213         } else {
214             ret = gm->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen);
215         }
216         (void)memset_s(g_transmitData, sizeof(g_transmitData), 0, sizeof(g_transmitData));
217         g_transmitDataLen = 0;
218         if (ret != HC_SUCCESS) {
219             g_asyncStatus = ASYNC_STATUS_ERROR;
220             return;
221         }
222         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
223             usleep(TEST_DEV_AUTH_SLEEP_TIME);
224         }
225         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
226             break;
227         }
228         if (g_transmitDataLen > 0) {
229             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
230         }
231     }
232     usleep(TEST_DEV_AUTH_SLEEP_TIME);
233     SetDeviceStatus(true);
234 }
235 
AuthDemoMember(void)236 static void AuthDemoMember(void)
237 {
238     g_asyncStatus = ASYNC_STATUS_WAITING;
239     bool isClient = true;
240     SetDeviceStatus(isClient);
241     const GroupAuthManager *ga = GetGaInstance();
242     int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_AUTH_PARAMS.c_str(), &g_gaCallback);
243     if (ret != HC_SUCCESS) {
244         g_asyncStatus = ASYNC_STATUS_ERROR;
245         return;
246     }
247     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
248         usleep(TEST_DEV_AUTH_SLEEP_TIME);
249     }
250     while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
251         isClient = !isClient;
252         SetDeviceStatus(isClient);
253         g_asyncStatus = ASYNC_STATUS_WAITING;
254         if (isClient) {
255             ret = ga->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen, &g_gaCallback);
256         } else {
257             ret = ga->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen, &g_gaCallback);
258         }
259         (void)memset_s(g_transmitData, sizeof(g_transmitData), 0, sizeof(g_transmitData));
260         g_transmitDataLen = 0;
261         if (ret != HC_SUCCESS) {
262             g_asyncStatus = ASYNC_STATUS_ERROR;
263             return;
264         }
265         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
266             usleep(TEST_DEV_AUTH_SLEEP_TIME);
267         }
268         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
269             break;
270         }
271         if (g_transmitDataLen > 0) {
272             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
273         }
274     }
275     SetDeviceStatus(true);
276 }
277 
GenerateTempKeyPair(Uint8Buff * keyAlias)278 static bool GenerateTempKeyPair(Uint8Buff *keyAlias)
279 {
280     int res = GetLoaderInstance()->checkKeyExist(keyAlias, false, DEFAULT_OS_ACCOUNT);
281     if (res == HC_SUCCESS) {
282         printf("Server key pair already exists\n");
283         return true;
284     }
285     printf("Key pair not exist, start to generate\n");
286     int32_t authId = 0;
287     Uint8Buff authIdBuff = { reinterpret_cast<uint8_t *>(&authId), sizeof(int32_t) };
288     ExtraInfo extInfo = { authIdBuff, -1, -1 };
289     KeyParams keyParams = { { keyAlias->val, keyAlias->length, true }, false, DEFAULT_OS_ACCOUNT };
290     res = GetLoaderInstance()->generateKeyPairWithStorage(&keyParams, TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN, P256,
291         KEY_PURPOSE_SIGN_VERIFY, &extInfo);
292     if (res != HC_SUCCESS) {
293         printf("Generate key pair failed\n");
294         return false;
295     }
296     printf("Generate key pair for server success\n");
297     return true;
298 }
299 
GetAsyCredentialJson(std::string registerInfo)300 static CJson *GetAsyCredentialJson(std::string registerInfo)
301 {
302     uint8_t keyAliasValue[] = "TestServerKeyPair";
303     Uint8Buff keyAlias = {
304         .val = keyAliasValue,
305         .length = sizeof(keyAliasValue)
306     };
307     if (!GenerateTempKeyPair(&keyAlias)) {
308         return nullptr;
309     }
310     uint8_t *serverPkVal = reinterpret_cast<uint8_t *>(HcMalloc(SERVER_PK_SIZE, 0));
311     Uint8Buff serverPk = {
312         .val = serverPkVal,
313         .length = SERVER_PK_SIZE
314     };
315 
316     KeyParams keyAliasParams = { { keyAlias.val, keyAlias.length, true }, false, DEFAULT_OS_ACCOUNT };
317     int32_t ret = GetLoaderInstance()->exportPublicKey(&keyAliasParams, &serverPk);
318     if (ret != HC_SUCCESS) {
319         printf("export PublicKey failed\n");
320         HcFree(serverPkVal);
321         return nullptr;
322     }
323 
324     Uint8Buff messageBuff = {
325         .val = reinterpret_cast<uint8_t *>(const_cast<char *>(registerInfo.c_str())),
326         .length = registerInfo.length() + 1
327     };
328     uint8_t *signatureValue = reinterpret_cast<uint8_t *>(HcMalloc(SIGNATURE_SIZE, 0));
329     Uint8Buff signature = {
330         .val = signatureValue,
331         .length = SIGNATURE_SIZE
332     };
333     ret = GetLoaderInstance()->sign(&keyAliasParams, &messageBuff, P256, &signature);
334     if (ret != HC_SUCCESS) {
335         printf("Sign pkInfo failed.\n");
336         HcFree(serverPkVal);
337         HcFree(signatureValue);
338         return nullptr;
339     }
340 
341     CJson *pkInfoJson = CreateJsonFromString(registerInfo.c_str());
342     CJson *credentialJson = CreateJson();
343     (void)AddIntToJson(credentialJson, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
344     (void)AddByteToJson(credentialJson, FIELD_SERVER_PK, serverPkVal, serverPk.length);
345     (void)AddByteToJson(credentialJson, FIELD_PK_INFO_SIGNATURE, signatureValue, signature.length);
346     (void)AddObjToJson(credentialJson, FIELD_PK_INFO, pkInfoJson);
347     FreeJson(pkInfoJson);
348     return credentialJson;
349 }
350 
CreateDemoIdenticalAccountGroup(int32_t osAccountId,const char * userId,const char * registerInfoParams)351 static void CreateDemoIdenticalAccountGroup(int32_t osAccountId, const char *userId,
352     const char *registerInfoParams)
353 {
354     g_asyncStatus = ASYNC_STATUS_WAITING;
355     const DeviceGroupManager *gm = GetGmInstance();
356     char *returnData = nullptr;
357     int32_t ret = gm->getRegisterInfo(registerInfoParams, &returnData);
358     std::string registerInfo(returnData);
359 
360     CJson *credJson = GetAsyCredentialJson(registerInfo);
361     CJson *json = CreateJson();
362     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
363     AddStringToJson(json, FIELD_USER_ID, userId);
364     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
365     char *jsonStr = PackJsonToString(json);
366     FreeJson(credJson);
367     FreeJson(json);
368     gm->destroyInfo(&returnData);
369     ret = gm->createGroup(osAccountId, TEST_REQ_ID, TEST_APP_ID.c_str(), jsonStr);
370     FreeJsonString(jsonStr);
371     if (ret != HC_SUCCESS) {
372         return;
373     }
374     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
375         usleep(TEST_DEV_AUTH_SLEEP_TIME);
376     }
377 }
378 
CreateClientSymIdenticalAccountGroup(void)379 static void CreateClientSymIdenticalAccountGroup(void)
380 {
381     g_asyncStatus = ASYNC_STATUS_WAITING;
382     const DeviceGroupManager *gm = GetGmInstance();
383 
384     CJson *credJson = CreateJson();
385     (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
386     (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE.c_str());
387     CJson *json = CreateJson();
388     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
389     AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID.c_str());
390     AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID.c_str());
391     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
392     char *jsonStr = PackJsonToString(json);
393     FreeJson(credJson);
394     FreeJson(json);
395     (void)gm->createGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), jsonStr);
396     FreeJsonString(jsonStr);
397     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
398         usleep(TEST_DEV_AUTH_SLEEP_TIME);
399     }
400 }
401 
CreateServerSymIdenticalAccountGroup(void)402 static void CreateServerSymIdenticalAccountGroup(void)
403 {
404     g_asyncStatus = ASYNC_STATUS_WAITING;
405     const DeviceGroupManager *gm = GetGmInstance();
406 
407     CJson *credJson = CreateJson();
408     (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
409     (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE.c_str());
410     CJson *json = CreateJson();
411     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
412     AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2.c_str());
413     AddStringToJson(json, FIELD_USER_ID, TEST_USER_ID.c_str());
414     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
415     char *jsonStr = PackJsonToString(json);
416     FreeJson(credJson);
417     FreeJson(json);
418     (void)gm->createGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID.c_str(), jsonStr);
419     FreeJsonString(jsonStr);
420     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
421         usleep(TEST_DEV_AUTH_SLEEP_TIME);
422     }
423 }
424 
GetAddMultiParams(int32_t osAccountId,const char * udid,const char * deviceId,const char * userId,const char * registerInfoParams)425 static CJson *GetAddMultiParams(int32_t osAccountId, const char *udid, const char *deviceId, const char *userId,
426     const char *registerInfoParams)
427 {
428     const DeviceGroupManager *gm = GetGmInstance();
429     if (gm == nullptr) {
430         return nullptr;
431     }
432     char *returnData = nullptr;
433     int32_t ret = gm->getRegisterInfo(registerInfoParams, &returnData);
434     if (ret != HC_SUCCESS) {
435         return nullptr;
436     }
437     std::string registerInfo(returnData);
438     CJson *credJson = GetAsyCredentialJson(registerInfo);
439     gm->destroyInfo(&returnData);
440     if (credJson == nullptr) {
441         return nullptr;
442     }
443 
444     CJson *credInfo = CreateJson();
445     AddStringToJson(credInfo, FIELD_UDID, udid);
446     AddStringToJson(credInfo, FIELD_DEVICE_ID, deviceId);
447     AddStringToJson(credInfo, FIELD_USER_ID, userId);
448     AddObjToJson(credInfo, FIELD_CREDENTIAL, credJson);
449 
450     CJson *deviceList = CreateJsonArray();
451     AddObjToArray(deviceList, credInfo);
452     CJson *addMultiParam = CreateJson();
453     AddObjToJson(addMultiParam, FIELD_DEVICE_LIST, deviceList);
454     AddStringToJson(addMultiParam, FIELD_UDID, udid);
455 
456     FreeJson(credJson);
457     FreeJson(deviceList);
458     return addMultiParam;
459 }
460 
GenerateSeed(Uint8Buff * seed)461 static int32_t GenerateSeed(Uint8Buff *seed)
462 {
463     uint8_t *random = (uint8_t *)HcMalloc(SEED_LEN, 0);
464     if (random == nullptr) {
465         LOGE("malloc random failed");
466         return HC_ERR_ALLOC_MEMORY;
467     }
468     Uint8Buff randomBuf = { random, SEED_LEN };
469     int ret = GetLoaderInstance()->generateRandom(&randomBuf);
470     if (ret != 0) {
471         LOGE("generate random failed, ret:%d", ret);
472         HcFree(random);
473         return ret;
474     }
475     clock_t times = 0;
476     uint8_t *input = (uint8_t *)HcMalloc(SEED_LEN + sizeof(clock_t), 0);
477     if (input == nullptr) {
478         LOGE("malloc failed");
479         HcFree(random);
480         return HC_ERR_ALLOC_MEMORY;
481     }
482     if (memcpy_s(input, SEED_LEN + sizeof(clock_t), random, SEED_LEN) != EOK) {
483         LOGE("memcpy seed failed.");
484         HcFree(random);
485         HcFree(input);
486         return HC_ERR_MEMORY_COPY;
487     }
488     if (memcpy_s(input + SEED_LEN, sizeof(clock_t), &times, sizeof(clock_t)) != EOK) {
489         LOGE("memcpy times failed.");
490         HcFree(random);
491         HcFree(input);
492         return HC_ERR_MEMORY_COPY;
493     }
494     Uint8Buff inputBuf = { input, SEED_LEN + sizeof(clock_t) };
495     ret = GetLoaderInstance()->sha256(&inputBuf, seed);
496     if (ret != HC_SUCCESS) {
497         LOGE("sha256 failed.");
498     }
499     HcFree(random);
500     HcFree(input);
501     return ret;
502 }
503 
GetSeedValue(Uint8Buff * seedBuff)504 static int32_t GetSeedValue(Uint8Buff *seedBuff)
505 {
506     seedBuff->val = (uint8_t *)HcMalloc(SEED_LEN, 0);
507     if (seedBuff->val == NULL) {
508         LOGE("Failed to alloc seed memory!");
509         return HC_ERR_ALLOC_MEMORY;
510     }
511     seedBuff->length = SEED_LEN;
512     int32_t ret = GenerateSeed(seedBuff);
513     if (ret != HC_SUCCESS) {
514         LOGE("Failed to generate seed!");
515         FreeUint8Buff(seedBuff);
516     }
517     return ret;
518 }
519 
GetNonceValue(Uint8Buff * nonceBuff)520 static int32_t GetNonceValue(Uint8Buff *nonceBuff)
521 {
522     nonceBuff->val = (uint8_t *)HcMalloc(PAKE_NONCE_LEN, 0);
523     if (nonceBuff->val == NULL) {
524         LOGE("Failed to malloc nonce value!");
525         return HC_ERR_ALLOC_MEMORY;
526     }
527     nonceBuff->length = PAKE_NONCE_LEN;
528     int32_t ret = GetLoaderInstance()->generateRandom(nonceBuff);
529     if (ret != HC_SUCCESS) {
530         LOGE("Failed to generate random!");
531         FreeUint8Buff(nonceBuff);
532     }
533     return ret;
534 }
535 
GetCertInfo(int32_t osAccountId,const char * userId,const char * deviceId,CertInfo * certInfo)536 static void GetCertInfo(int32_t osAccountId, const char *userId, const char *deviceId, CertInfo *certInfo)
537 {
538     AccountToken *token = CreateAccountToken();
539     (void)GetAccountAuthTokenManager()->getToken(osAccountId, token, userId, deviceId);
540     certInfo->pkInfoStr.val = (uint8_t *)HcMalloc(token->pkInfoStr.length, 0);
541     certInfo->pkInfoStr.length = token->pkInfoStr.length;
542     (void)memcpy_s(certInfo->pkInfoStr.val, certInfo->pkInfoStr.length, token->pkInfoStr.val, token->pkInfoStr.length);
543     certInfo->pkInfoSignature.val = (uint8_t *)HcMalloc(token->pkInfoSignature.length, 0);
544     certInfo->pkInfoSignature.length = token->pkInfoSignature.length;
545     (void)memcpy_s(certInfo->pkInfoSignature.val, certInfo->pkInfoSignature.length, token->pkInfoSignature.val,
546         token->pkInfoSignature.length);
547     certInfo->signAlg = P256;
548     DestroyAccountToken(token);
549 }
550 
CredsManagerTest01(void)551 static void CredsManagerTest01(void)
552 {
553     int32_t res = GetCredInfosByPeerIdentity(nullptr, nullptr);
554     CJson *json = CreateJson();
555     res = GetCredInfosByPeerIdentity(json, nullptr);
556     FreeJson(json);
557     if (res != HC_SUCCESS) {
558         return;
559     }
560 }
561 
CredsManagerTest02(void)562 static void CredsManagerTest02(void)
563 {
564     CJson *json = CreateJson();
565     IdentityInfoVec vec = CreateIdentityInfoVec();
566     (void)AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
567     (void)GetCredInfosByPeerIdentity(json, &vec);
568     FreeJson(json);
569     ClearIdentityInfoVec(&vec);
570 }
571 
CredsManagerTest03(void)572 static void CredsManagerTest03(void)
573 {
574     CJson *json = CreateJson();
575     IdentityInfoVec vec = CreateIdentityInfoVec();
576     (void)GetCredInfosByPeerIdentity(json, &vec);
577     FreeJson(json);
578     ClearIdentityInfoVec(&vec);
579 }
580 
CredsManagerTest04(void)581 static void CredsManagerTest04(void)
582 {
583     CJson *json = CreateJson();
584     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
585     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
586     IdentityInfoVec vec = CreateIdentityInfoVec();
587     (void)GetCredInfosByPeerIdentity(json, &vec);
588     FreeJson(json);
589     ClearIdentityInfoVec(&vec);
590 }
591 
CredsManagerTest05(void)592 static void CredsManagerTest05(void)
593 {
594     CJson *json = CreateJson();
595     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
596     (void)AddStringToJson(json, FIELD_SERVICE_TYPE, TEST_GROUP_ID.c_str());
597     IdentityInfoVec vec = CreateIdentityInfoVec();
598     (void)GetCredInfosByPeerIdentity(json, &vec);
599     FreeJson(json);
600     ClearIdentityInfoVec(&vec);
601 }
602 
CredsManagerTest06(void)603 static void CredsManagerTest06(void)
604 {
605     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
606 
607     CJson *json = CreateJson();
608     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
609     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
610     IdentityInfoVec vec = CreateIdentityInfoVec();
611     (void)GetCredInfosByPeerIdentity(json, &vec);
612     FreeJson(json);
613     ClearIdentityInfoVec(&vec);
614 }
615 
CredsManagerTest07(void)616 static void CredsManagerTest07(void)
617 {
618     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
619     CJson *json = CreateJson();
620     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
621     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
622     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
623     IdentityInfoVec vec = CreateIdentityInfoVec();
624     (void)GetCredInfosByPeerIdentity(json, &vec);
625     FreeJson(json);
626     ClearIdentityInfoVec(&vec);
627 }
628 
CredsManagerTest08(void)629 static void CredsManagerTest08(void)
630 {
631     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
632     CJson *json = CreateJson();
633     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
634     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
635     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
636     (void)AddStringToJson(json, FIELD_PEER_UDID, TEST_UDID_SERVER.c_str());
637     IdentityInfoVec vec = CreateIdentityInfoVec();
638     (void)GetCredInfosByPeerIdentity(json, &vec);
639     FreeJson(json);
640     ClearIdentityInfoVec(&vec);
641 }
642 
CredsManagerTest09(void)643 static void CredsManagerTest09(void)
644 {
645     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
646     CJson *json = CreateJson();
647     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
648     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
649     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
650     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
651     IdentityInfoVec vec = CreateIdentityInfoVec();
652     (void)GetCredInfosByPeerIdentity(json, &vec);
653     FreeJson(json);
654     ClearIdentityInfoVec(&vec);
655 }
656 
CredsManagerTest10(void)657 static void CredsManagerTest10(void)
658 {
659     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS2.c_str());
660     CJson *json = CreateJson();
661     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
662     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
663     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID2.c_str());
664     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
665     IdentityInfoVec vec = CreateIdentityInfoVec();
666     (void)GetCredInfosByPeerIdentity(json, &vec);
667     FreeJson(json);
668     ClearIdentityInfoVec(&vec);
669 }
670 
CredsManagerTest11(void)671 static void CredsManagerTest11(void)
672 {
673     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
674     AddDemoMember();
675     CJson *json = CreateJson();
676     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
677     (void)AddStringToJson(json, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
678     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
679     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
680     IdentityInfoVec vec = CreateIdentityInfoVec();
681     (void)GetCredInfosByPeerIdentity(json, &vec);
682     FreeJson(json);
683     ClearIdentityInfoVec(&vec);
684 }
685 
CredsManagerTest12(void)686 static void CredsManagerTest12(void)
687 {
688     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
689     AddDemoMember();
690     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
691 
692     CJson *json = CreateJson();
693     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
694     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
695     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
696     IdentityInfoVec vec = CreateIdentityInfoVec();
697     (void)GetCredInfosByPeerIdentity(json, &vec);
698     FreeJson(json);
699     ClearIdentityInfoVec(&vec);
700 }
701 
CredsManagerTest13(void)702 static void CredsManagerTest13(void)
703 {
704     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
705     AddDemoMember();
706     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
707     CJson *json = CreateJson();
708     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
709     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
710     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
711     (void)AddBoolToJson(json, FIELD_IS_DEVICE_LEVEL, true);
712     IdentityInfoVec vec = CreateIdentityInfoVec();
713     (void)GetCredInfosByPeerIdentity(json, &vec);
714     FreeJson(json);
715     ClearIdentityInfoVec(&vec);
716 }
717 
CredsManagerTest14(void)718 static void CredsManagerTest14(void)
719 {
720     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
721     const DeviceGroupManager *gm = GetGmInstance();
722     int32_t res = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID.c_str(), TEST_ADD_MULTI_PARAM.c_str());
723     CJson *json = CreateJson();
724     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
725     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
726     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
727     (void)AddBoolToJson(json, FIELD_IS_DEVICE_LEVEL, true);
728     IdentityInfoVec vec = CreateIdentityInfoVec();
729     res = GetCredInfosByPeerIdentity(json, &vec);
730     FreeJson(json);
731     ClearIdentityInfoVec(&vec);
732     if (res != HC_SUCCESS) {
733         return;
734     }
735 }
736 
CredsManagerTest15(void)737 static void CredsManagerTest15(void)
738 {
739     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
740     CJson *addMultiParam = GetAddMultiParams(DEFAULT_OS_ACCOUNT, TEST_UDID_SERVER.c_str(), TEST_AUTH_ID2.c_str(),
741         TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM2.c_str());
742     AddStringToJson(addMultiParam, FIELD_GROUP_ID, TEST_USER_ID.c_str());
743     AddIntToJson(addMultiParam, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
744     char *addMultiParamStr = PackJsonToString(addMultiParam);
745     FreeJson(addMultiParam);
746     const DeviceGroupManager *gm = GetGmInstance();
747     int32_t res = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID.c_str(), addMultiParamStr);
748     FreeJsonString(addMultiParamStr);
749     if (res != HC_SUCCESS) {
750         return;
751     }
752     CJson *json = CreateJson();
753     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
754     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
755     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
756     (void)AddBoolToJson(json, FIELD_IS_DEVICE_LEVEL, true);
757     IdentityInfoVec vec = CreateIdentityInfoVec();
758     res = GetCredInfosByPeerIdentity(json, &vec);
759     FreeJson(json);
760     ClearIdentityInfoVec(&vec);
761     if (res != HC_SUCCESS) {
762         return;
763     }
764 }
765 
CredsManagerTest16(void)766 static void CredsManagerTest16(void)
767 {
768     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
769     SetDeviceStatus(false);
770     CreateDemoIdenticalAccountGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM2.c_str());
771     SetDeviceStatus(true);
772     AuthDemoMember();
773     CJson *json = CreateJson();
774     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
775     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
776     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
777     (void)AddBoolToJson(json, FIELD_IS_DEVICE_LEVEL, true);
778     IdentityInfoVec vec = CreateIdentityInfoVec();
779     (void)GetCredInfosByPeerIdentity(json, &vec);
780     FreeJson(json);
781     ClearIdentityInfoVec(&vec);
782 }
783 
CredsManagerTest17(void)784 static void CredsManagerTest17(void)
785 {
786     CreateClientSymIdenticalAccountGroup();
787     CJson *json = CreateJson();
788     (void)AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
789     (void)AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID.c_str());
790     (void)AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
791     (void)AddBoolToJson(json, FIELD_IS_DEVICE_LEVEL, true);
792     IdentityInfoVec vec = CreateIdentityInfoVec();
793     (void)GetCredInfosByPeerIdentity(json, &vec);
794     FreeJson(json);
795     ClearIdentityInfoVec(&vec);
796 }
797 
CredsManagerTest18(void)798 static void CredsManagerTest18(void)
799 {
800     int32_t res = GetCredInfoByPeerUrl(nullptr, nullptr, nullptr);
801     CJson *json = CreateJson();
802     res = GetCredInfoByPeerUrl(json, nullptr, nullptr);
803     if (res != HC_SUCCESS) {
804         FreeJson(json);
805         return;
806     }
807     Uint8Buff presharedUrl = { nullptr, 0 };
808     res = GetCredInfoByPeerUrl(json, &presharedUrl, nullptr);
809     FreeJson(json);
810     if (res != HC_SUCCESS) {
811         return;
812     }
813 }
814 
CredsManagerTest19(void)815 static void CredsManagerTest19(void)
816 {
817     CJson *json = CreateJson();
818     Uint8Buff presharedUrl = { nullptr, 0 };
819     IdentityInfo *info = nullptr;
820     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
821     FreeJson(json);
822 }
823 
CredsManagerTest20(void)824 static void CredsManagerTest20(void)
825 {
826     CJson *json = CreateJson();
827     CJson *presharedUrlJson = CreateJson();
828     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
829     FreeJson(presharedUrlJson);
830     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
831     IdentityInfo *info = nullptr;
832     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
833     FreeJsonString(presharedUrlStr);
834     FreeJson(json);
835 }
836 
CredsManagerTest21(void)837 static void CredsManagerTest21(void)
838 {
839     CJson *json = CreateJson();
840     CJson *presharedUrlJson = CreateJson();
841     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
842     AddIntToJson(presharedUrlJson, PRESHARED_URL_KEY_TYPE, KEY_TYPE_SYM);
843     AddIntToJson(presharedUrlJson, PRESHARED_URL_CREDENTIAL_TYPE, PRE_SHARED);
844     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
845     FreeJson(presharedUrlJson);
846     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
847     IdentityInfo *info = nullptr;
848     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
849     DestroyIdentityInfo(info);
850     FreeJsonString(presharedUrlStr);
851     FreeJson(json);
852 }
853 
CredsManagerTest22(void)854 static void CredsManagerTest22(void)
855 {
856     CJson *json = CreateJson();
857     CJson *presharedUrlJson = CreateJson();
858     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
859     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
860     FreeJson(presharedUrlJson);
861     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
862     IdentityInfo *info = nullptr;
863     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
864     FreeJsonString(presharedUrlStr);
865     FreeJson(json);
866 }
867 
CredsManagerTest23(void)868 static void CredsManagerTest23(void)
869 {
870     CJson *json = CreateJson();
871     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
872     CJson *presharedUrlJson = CreateJson();
873     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
874     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
875     FreeJson(presharedUrlJson);
876     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
877     IdentityInfo *info = nullptr;
878     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
879     FreeJsonString(presharedUrlStr);
880     FreeJson(json);
881 }
882 
CredsManagerTest24(void)883 static void CredsManagerTest24(void)
884 {
885     CJson *json = CreateJson();
886     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
887     CJson *presharedUrlJson = CreateJson();
888     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
889     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
890     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
891     FreeJson(presharedUrlJson);
892     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
893     IdentityInfo *info = nullptr;
894     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
895     FreeJsonString(presharedUrlStr);
896     FreeJson(json);
897 }
898 
CredsManagerTest25(void)899 static void CredsManagerTest25(void)
900 {
901     CreateClientSymIdenticalAccountGroup();
902     CJson *json = CreateJson();
903     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
904     CJson *presharedUrlJson = CreateJson();
905     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
906     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
907     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
908     FreeJson(presharedUrlJson);
909     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
910     IdentityInfo *info = nullptr;
911     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
912     DestroyIdentityInfo(info);
913     FreeJsonString(presharedUrlStr);
914     FreeJson(json);
915 }
916 
CredsManagerTest26(void)917 static void CredsManagerTest26(void)
918 {
919     CJson *json = CreateJson();
920     CJson *presharedUrlJson = CreateJson();
921     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, -1);
922     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
923     FreeJson(presharedUrlJson);
924     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
925     IdentityInfo *info = nullptr;
926     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
927     FreeJsonString(presharedUrlStr);
928     FreeJson(json);
929 }
930 
CredsManagerTest27(void)931 static void CredsManagerTest27(void)
932 {
933     CJson *json = CreateJson();
934     CJson *presharedUrlJson = CreateJson();
935     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
936     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
937     FreeJson(presharedUrlJson);
938     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
939     IdentityInfo *info = nullptr;
940     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
941     FreeJsonString(presharedUrlStr);
942     FreeJson(json);
943 }
944 
CredsManagerTest28(void)945 static void CredsManagerTest28(void)
946 {
947     CJson *json = CreateJson();
948     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
949     CJson *presharedUrlJson = CreateJson();
950     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
951     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
952     FreeJson(presharedUrlJson);
953     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
954     IdentityInfo *info = nullptr;
955     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
956     FreeJsonString(presharedUrlStr);
957     FreeJson(json);
958 }
959 
CredsManagerTest29(void)960 static void CredsManagerTest29(void)
961 {
962     CJson *json = CreateJson();
963     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
964     CJson *presharedUrlJson = CreateJson();
965     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
966     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
967     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
968     FreeJson(presharedUrlJson);
969     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
970     IdentityInfo *info = nullptr;
971     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
972     FreeJsonString(presharedUrlStr);
973     FreeJson(json);
974 }
975 
CredsManagerTest30(void)976 static void CredsManagerTest30(void)
977 {
978     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
979     CJson *json = CreateJson();
980     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
981     CJson *presharedUrlJson = CreateJson();
982     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
983     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
984     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
985     FreeJson(presharedUrlJson);
986     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
987     IdentityInfo *info = nullptr;
988     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
989     FreeJsonString(presharedUrlStr);
990     FreeJson(json);
991 }
992 
CredsManagerTest31(void)993 static void CredsManagerTest31(void)
994 {
995     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
996     CJson *json = CreateJson();
997     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
998     AddStringToJson(json, FIELD_PEER_UDID, TEST_UDID_SERVER.c_str());
999     CJson *presharedUrlJson = CreateJson();
1000     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1001     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1002     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1003     FreeJson(presharedUrlJson);
1004     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
1005     IdentityInfo *info = nullptr;
1006     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
1007     FreeJsonString(presharedUrlStr);
1008     FreeJson(json);
1009 }
1010 
CredsManagerTest32(void)1011 static void CredsManagerTest32(void)
1012 {
1013     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1014     CJson *json = CreateJson();
1015     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1016     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1017     CJson *presharedUrlJson = CreateJson();
1018     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1019     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1020     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1021     FreeJson(presharedUrlJson);
1022     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
1023     IdentityInfo *info = nullptr;
1024     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
1025     FreeJsonString(presharedUrlStr);
1026     FreeJson(json);
1027 }
1028 
CredsManagerTest33(void)1029 static void CredsManagerTest33(void)
1030 {
1031     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1032     AddDemoMember();
1033     CJson *json = CreateJson();
1034     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1035     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1036     CJson *presharedUrlJson = CreateJson();
1037     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1038     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1039     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1040     FreeJson(presharedUrlJson);
1041     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
1042     IdentityInfo *info = nullptr;
1043     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
1044     FreeJsonString(presharedUrlStr);
1045     FreeJson(json);
1046 }
1047 
CredsManagerTest34(void)1048 static void CredsManagerTest34(void)
1049 {
1050     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1051     AddDemoMember();
1052     CJson *json = CreateJson();
1053     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1054     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1055     CJson *presharedUrlJson = CreateJson();
1056     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1057     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1058     AddIntToJson(presharedUrlJson, PRESHARED_URL_KEY_TYPE, KEY_TYPE_ASYM);
1059     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1060     FreeJson(presharedUrlJson);
1061     Uint8Buff presharedUrl = { (uint8_t *)presharedUrlStr, strlen(presharedUrlStr) + 1 };
1062     IdentityInfo *info = nullptr;
1063     (void)GetCredInfoByPeerUrl(json, &presharedUrl, &info);
1064     DestroyIdentityInfo(info);
1065     FreeJsonString(presharedUrlStr);
1066     FreeJson(json);
1067 }
1068 
CredsManagerTestInner(CertInfo * certInfo,CJson * json,IdentityInfo * info)1069 static void CredsManagerTestInner(CertInfo *certInfo, CJson *json, IdentityInfo *info)
1070 {
1071     CJson *pkInfoJson = CreateJson();
1072     char *pkInfoStr = PackJsonToString(pkInfoJson);
1073     FreeJson(pkInfoJson);
1074     certInfo->pkInfoStr.val = reinterpret_cast<uint8_t *>(pkInfoStr);
1075     certInfo->pkInfoStr.length = strlen(pkInfoStr) + 1;
1076     int32_t res = GetCredInfoByPeerCert(json, certInfo, &info);
1077     FreeJsonString(pkInfoStr);
1078     if (res != HC_SUCCESS) {
1079         return;
1080     }
1081     pkInfoJson = CreateJson();
1082     AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_USER_ID.c_str());
1083     pkInfoStr = PackJsonToString(pkInfoJson);
1084     FreeJson(pkInfoJson);
1085     certInfo->pkInfoStr.val = reinterpret_cast<uint8_t *>(pkInfoStr);
1086     certInfo->pkInfoStr.length = strlen(pkInfoStr) + 1;
1087     (void)GetCredInfoByPeerCert(json, certInfo, &info);
1088     FreeJsonString(pkInfoStr);
1089 }
1090 
CredsManagerTest35(void)1091 static void CredsManagerTest35(void)
1092 {
1093     int32_t res = GetCredInfoByPeerCert(nullptr, nullptr, nullptr);
1094     CJson *json = CreateJson();
1095     res = GetCredInfoByPeerCert(json, nullptr, nullptr);
1096     if (res != HC_SUCCESS) {
1097         FreeJson(json);
1098         return;
1099     }
1100     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1101     res = GetCredInfoByPeerCert(json, &certInfo, nullptr);
1102     if (res != HC_SUCCESS) {
1103         FreeJson(json);
1104         return;
1105     }
1106     IdentityInfo *info = nullptr;
1107     res = GetCredInfoByPeerCert(json, &certInfo, &info);
1108     if (res != HC_SUCCESS) {
1109         FreeJson(json);
1110         return;
1111     }
1112     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1113     res = GetCredInfoByPeerCert(json, &certInfo, &info);
1114     if (res != HC_SUCCESS) {
1115         FreeJson(json);
1116         return;
1117     }
1118     CredsManagerTestInner(&certInfo, json, info);
1119     FreeJson(json);
1120 }
1121 
CredsManagerTest36(void)1122 static void CredsManagerTest36(void)
1123 {
1124     CreateClientSymIdenticalAccountGroup();
1125     CJson *json = CreateJson();
1126     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1127     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1128     CJson *pkInfoJson = CreateJson();
1129     AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_USER_ID.c_str());
1130     char *pkInfoStr = PackJsonToString(pkInfoJson);
1131     FreeJson(pkInfoJson);
1132     certInfo.pkInfoStr.val = (uint8_t *)pkInfoStr;
1133     certInfo.pkInfoStr.length = strlen(pkInfoStr) + 1;
1134     IdentityInfo *info = nullptr;
1135     (void)GetCredInfoByPeerCert(json, &certInfo, &info);
1136     FreeJsonString(pkInfoStr);
1137     FreeJson(json);
1138 }
1139 
CredsManagerTest37(void)1140 static void CredsManagerTest37(void)
1141 {
1142     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
1143     CJson *json = CreateJson();
1144     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1145     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1146     CJson *pkInfoJson = CreateJson();
1147     AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_USER_ID.c_str());
1148     char *pkInfoStr = PackJsonToString(pkInfoJson);
1149     FreeJson(pkInfoJson);
1150     certInfo.pkInfoStr.val = (uint8_t *)pkInfoStr;
1151     certInfo.pkInfoStr.length = strlen(pkInfoStr) + 1;
1152     IdentityInfo *info = nullptr;
1153     (void)GetCredInfoByPeerCert(json, &certInfo, &info);
1154     DestroyIdentityInfo(info);
1155     FreeJsonString(pkInfoStr);
1156     FreeJson(json);
1157 }
1158 
CredsManagerTest38(void)1159 static void CredsManagerTest38(void)
1160 {
1161     int32_t res = GetSharedSecretByUrl(nullptr, nullptr, ALG_ISO, nullptr);
1162     CJson *json = CreateJson();
1163     res = GetSharedSecretByUrl(json, nullptr, ALG_ISO, nullptr);
1164     if (res != HC_SUCCESS) {
1165         FreeJson(json);
1166         return;
1167     }
1168     Uint8Buff presharedUrl = { nullptr, 0 };
1169     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, nullptr);
1170     if (res != HC_SUCCESS) {
1171         FreeJson(json);
1172         return;
1173     }
1174     Uint8Buff sharedSecret = { nullptr, 0 };
1175     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1176     if (res != HC_SUCCESS) {
1177         FreeJson(json);
1178         return;
1179     }
1180     CJson *presharedUrlJson = CreateJson();
1181     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1182     FreeJson(presharedUrlJson);
1183     presharedUrl.val = (uint8_t *)presharedUrlStr;
1184     presharedUrl.length = strlen(presharedUrlStr) + 1;
1185     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1186     FreeJsonString(presharedUrlStr);
1187     if (res != HC_SUCCESS) {
1188         FreeJson(json);
1189         return;
1190     }
1191     presharedUrlJson = CreateJson();
1192     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
1193     AddIntToJson(presharedUrlJson, PRESHARED_URL_KEY_TYPE, KEY_TYPE_SYM);
1194     presharedUrlStr = PackJsonToString(presharedUrlJson);
1195     FreeJson(presharedUrlJson);
1196     presharedUrl.val = (uint8_t *)presharedUrlStr;
1197     presharedUrl.length = strlen(presharedUrlStr) + 1;
1198     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1199     FreeJsonString(presharedUrlStr);
1200     FreeJson(json);
1201     if (res != HC_SUCCESS) {
1202         return;
1203     }
1204 }
1205 
CredsManagerTest39(void)1206 static void CredsManagerTest39(void)
1207 {
1208     CJson *json = CreateJson();
1209     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
1210     Uint8Buff presharedUrl = { nullptr, 0 };
1211     CJson *presharedUrlJson = CreateJson();
1212     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
1213     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1214     FreeJson(presharedUrlJson);
1215     presharedUrl.val = (uint8_t *)presharedUrlStr;
1216     presharedUrl.length = strlen(presharedUrlStr) + 1;
1217     Uint8Buff sharedSecret = { nullptr, 0 };
1218     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1219     FreeJsonString(presharedUrlStr);
1220     FreeJson(json);
1221 }
1222 
CredsManagerTest40(void)1223 static void CredsManagerTest40(void)
1224 {
1225     CJson *json = CreateJson();
1226     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
1227     Uint8Buff seedBuff = { nullptr, 0 };
1228     int32_t res = GetSeedValue(&seedBuff);
1229     if (res != HC_SUCCESS) {
1230         FreeJson(json);
1231         return;
1232     }
1233     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1234     HcFree(seedBuff.val);
1235     Uint8Buff presharedUrl = { nullptr, 0 };
1236     CJson *presharedUrlJson = CreateJson();
1237     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
1238     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1239     FreeJson(presharedUrlJson);
1240     presharedUrl.val = (uint8_t *)presharedUrlStr;
1241     presharedUrl.length = strlen(presharedUrlStr) + 1;
1242     Uint8Buff sharedSecret = { nullptr, 0 };
1243     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1244     FreeJsonString(presharedUrlStr);
1245     HcFree(sharedSecret.val);
1246     FreeJson(json);
1247     if (res != HC_SUCCESS) {
1248         return;
1249     }
1250 }
1251 
CredsManagerTest41(void)1252 static void CredsManagerTest41(void)
1253 {
1254     CJson *json = CreateJson();
1255     Uint8Buff presharedUrl = { nullptr, 0 };
1256     CJson *presharedUrlJson = CreateJson();
1257     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
1258     AddIntToJson(presharedUrlJson, PRESHARED_URL_KEY_TYPE, KEY_TYPE_SYM);
1259     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1260     FreeJson(presharedUrlJson);
1261     presharedUrl.val = (uint8_t *)presharedUrlStr;
1262     presharedUrl.length = strlen(presharedUrlStr) + 1;
1263     Uint8Buff sharedSecret = { nullptr, 0 };
1264     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1265     FreeJsonString(presharedUrlStr);
1266     FreeJson(json);
1267 }
1268 
CredsManagerTest42(void)1269 static void CredsManagerTest42(void)
1270 {
1271     CJson *json = CreateJson();
1272     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE.c_str());
1273     Uint8Buff presharedUrl = { nullptr, 0 };
1274     CJson *presharedUrlJson = CreateJson();
1275     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_PIN);
1276     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1277     FreeJson(presharedUrlJson);
1278     presharedUrl.val = (uint8_t *)presharedUrlStr;
1279     presharedUrl.length = strlen(presharedUrlStr) + 1;
1280     Uint8Buff sharedSecret = { nullptr, 0 };
1281     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1282     FreeJsonString(presharedUrlStr);
1283     HcFree(sharedSecret.val);
1284     FreeJson(json);
1285 }
1286 
CredsManagerTest43(void)1287 static void CredsManagerTest43(void)
1288 {
1289     CJson *json = CreateJson();
1290     Uint8Buff presharedUrl = { nullptr, 0 };
1291     CJson *presharedUrlJson = CreateJson();
1292     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, -1);
1293     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1294     FreeJson(presharedUrlJson);
1295     presharedUrl.val = (uint8_t *)presharedUrlStr;
1296     presharedUrl.length = strlen(presharedUrlStr) + 1;
1297     Uint8Buff sharedSecret = { nullptr, 0 };
1298     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1299     FreeJsonString(presharedUrlStr);
1300     FreeJson(json);
1301 }
1302 
CredsManagerTest44(void)1303 static void CredsManagerTest44(void)
1304 {
1305     CJson *json = CreateJson();
1306     Uint8Buff presharedUrl = { nullptr, 0 };
1307     CJson *presharedUrlJson = CreateJson();
1308     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1309     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1310     FreeJson(presharedUrlJson);
1311     presharedUrl.val = (uint8_t *)presharedUrlStr;
1312     presharedUrl.length = strlen(presharedUrlStr) + 1;
1313     Uint8Buff sharedSecret = { nullptr, 0 };
1314     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1315     FreeJsonString(presharedUrlStr);
1316     FreeJson(json);
1317 }
1318 
CredsManagerTest45(void)1319 static void CredsManagerTest45(void)
1320 {
1321     CJson *json = CreateJson();
1322     Uint8Buff presharedUrl = { nullptr, 0 };
1323     CJson *presharedUrlJson = CreateJson();
1324     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1325     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1326     FreeJson(presharedUrlJson);
1327     presharedUrl.val = (uint8_t *)presharedUrlStr;
1328     presharedUrl.length = strlen(presharedUrlStr) + 1;
1329     Uint8Buff sharedSecret = { nullptr, 0 };
1330     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1331     FreeJsonString(presharedUrlStr);
1332     FreeJson(json);
1333 }
1334 
CredsManagerTest46(void)1335 static void CredsManagerTest46(void)
1336 {
1337     CJson *json = CreateJson();
1338     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1339     Uint8Buff presharedUrl = { nullptr, 0 };
1340     CJson *presharedUrlJson = CreateJson();
1341     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1342     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1343     FreeJson(presharedUrlJson);
1344     presharedUrl.val = (uint8_t *)presharedUrlStr;
1345     presharedUrl.length = strlen(presharedUrlStr) + 1;
1346     Uint8Buff sharedSecret = { nullptr, 0 };
1347     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1348     FreeJsonString(presharedUrlStr);
1349     FreeJson(json);
1350 }
1351 
CredsManagerTest47(void)1352 static void CredsManagerTest47(void)
1353 {
1354     CJson *json = CreateJson();
1355     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1356     Uint8Buff presharedUrl = { nullptr, 0 };
1357     CJson *presharedUrlJson = CreateJson();
1358     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1359     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1360     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1361     FreeJson(presharedUrlJson);
1362     presharedUrl.val = (uint8_t *)presharedUrlStr;
1363     presharedUrl.length = strlen(presharedUrlStr) + 1;
1364     Uint8Buff sharedSecret = { nullptr, 0 };
1365     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1366     FreeJsonString(presharedUrlStr);
1367     FreeJson(json);
1368 }
1369 
CredsManagerTest48(void)1370 static void CredsManagerTest48(void)
1371 {
1372     CJson *json = CreateJson();
1373     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1374     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1375     Uint8Buff presharedUrl = { nullptr, 0 };
1376     CJson *presharedUrlJson = CreateJson();
1377     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1378     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1379     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1380     FreeJson(presharedUrlJson);
1381     presharedUrl.val = (uint8_t *)presharedUrlStr;
1382     presharedUrl.length = strlen(presharedUrlStr) + 1;
1383     Uint8Buff sharedSecret = { nullptr, 0 };
1384     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1385     FreeJsonString(presharedUrlStr);
1386     FreeJson(json);
1387 }
1388 
CredsManagerTest49(void)1389 static void CredsManagerTest49(void)
1390 {
1391     CreateClientSymIdenticalAccountGroup();
1392     CJson *json = CreateJson();
1393     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1394     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1395     Uint8Buff presharedUrl = { nullptr, 0 };
1396     CJson *presharedUrlJson = CreateJson();
1397     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1398     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1399     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1400     FreeJson(presharedUrlJson);
1401     presharedUrl.val = (uint8_t *)presharedUrlStr;
1402     presharedUrl.length = strlen(presharedUrlStr) + 1;
1403     Uint8Buff sharedSecret = { nullptr, 0 };
1404     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1405     FreeJsonString(presharedUrlStr);
1406     FreeJson(json);
1407 }
1408 
CredsManagerTest50(void)1409 static void CredsManagerTest50(void)
1410 {
1411     CreateClientSymIdenticalAccountGroup();
1412     CJson *json = CreateJson();
1413     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1414     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1415     Uint8Buff seedBuff = { nullptr, 0 };
1416     int32_t res = GetSeedValue(&seedBuff);
1417     if (res != HC_SUCCESS) {
1418         FreeJson(json);
1419         return;
1420     }
1421     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1422     HcFree(seedBuff.val);
1423     Uint8Buff presharedUrl = { nullptr, 0 };
1424     CJson *presharedUrlJson = CreateJson();
1425     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1426     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1427     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1428     FreeJson(presharedUrlJson);
1429     presharedUrl.val = (uint8_t *)presharedUrlStr;
1430     presharedUrl.length = strlen(presharedUrlStr) + 1;
1431     Uint8Buff sharedSecret = { nullptr, 0 };
1432     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1433     FreeJsonString(presharedUrlStr);
1434     HcFree(sharedSecret.val);
1435     FreeJson(json);
1436     if (res != HC_SUCCESS) {
1437         return;
1438     }
1439 }
1440 
CredsManagerTest51(void)1441 static void CredsManagerTest51(void)
1442 {
1443     CreateClientSymIdenticalAccountGroup();
1444     const DeviceGroupManager *gm = GetGmInstance();
1445     int32_t res = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID.c_str(), TEST_ADD_MULTI_PARAM.c_str());
1446     CJson *json = CreateJson();
1447     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1448     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1449     Uint8Buff seedBuff = { nullptr, 0 };
1450     res = GetSeedValue(&seedBuff);
1451     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1452     HcFree(seedBuff.val);
1453     if (res != HC_SUCCESS) {
1454         FreeJson(json);
1455         return;
1456     }
1457     Uint8Buff presharedUrl = { nullptr, 0 };
1458     CJson *presharedUrlJson = CreateJson();
1459     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1460     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1461     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1462     FreeJson(presharedUrlJson);
1463     presharedUrl.val = (uint8_t *)presharedUrlStr;
1464     presharedUrl.length = strlen(presharedUrlStr) + 1;
1465     Uint8Buff sharedSecret = { nullptr, 0 };
1466     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1467     FreeJsonString(presharedUrlStr);
1468     HcFree(sharedSecret.val);
1469     FreeJson(json);
1470     if (res != HC_SUCCESS) {
1471         return;
1472     }
1473 }
1474 
CredsManagerTest52(void)1475 static void CredsManagerTest52(void)
1476 {
1477     CreateClientSymIdenticalAccountGroup();
1478     SetDeviceStatus(false);
1479     CreateServerSymIdenticalAccountGroup();
1480     SetDeviceStatus(true);
1481     AuthDemoMember();
1482     CJson *json = CreateJson();
1483     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1484     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1485     Uint8Buff seedBuff = { nullptr, 0 };
1486     int32_t res = GetSeedValue(&seedBuff);
1487     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1488     HcFree(seedBuff.val);
1489     if (res != HC_SUCCESS) {
1490         FreeJson(json);
1491         return;
1492     }
1493     Uint8Buff presharedUrl = { nullptr, 0 };
1494     CJson *presharedUrlJson = CreateJson();
1495     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_UID);
1496     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_USER_ID.c_str());
1497     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1498     FreeJson(presharedUrlJson);
1499     presharedUrl.val = (uint8_t *)presharedUrlStr;
1500     presharedUrl.length = strlen(presharedUrlStr) + 1;
1501     Uint8Buff sharedSecret = { nullptr, 0 };
1502     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1503     FreeJsonString(presharedUrlStr);
1504     HcFree(sharedSecret.val);
1505     FreeJson(json);
1506     if (res != HC_SUCCESS) {
1507         return;
1508     }
1509 }
1510 
CredsManagerTest53(void)1511 static void CredsManagerTest53(void)
1512 {
1513     CJson *json = CreateJson();
1514     Uint8Buff presharedUrl = { nullptr, 0 };
1515     CJson *presharedUrlJson = CreateJson();
1516     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1517     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1518     FreeJson(presharedUrlJson);
1519     presharedUrl.val = (uint8_t *)presharedUrlStr;
1520     presharedUrl.length = strlen(presharedUrlStr) + 1;
1521     Uint8Buff sharedSecret = { nullptr, 0 };
1522     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1523     FreeJsonString(presharedUrlStr);
1524     FreeJson(json);
1525 }
1526 
CredsManagerTest54(void)1527 static void CredsManagerTest54(void)
1528 {
1529     CJson *json = CreateJson();
1530     Uint8Buff presharedUrl = { nullptr, 0 };
1531     CJson *presharedUrlJson = CreateJson();
1532     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1533     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1534     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1535     FreeJson(presharedUrlJson);
1536     presharedUrl.val = (uint8_t *)presharedUrlStr;
1537     presharedUrl.length = strlen(presharedUrlStr) + 1;
1538     Uint8Buff sharedSecret = { nullptr, 0 };
1539     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1540     FreeJsonString(presharedUrlStr);
1541     FreeJson(json);
1542 }
1543 
CredsManagerTest55(void)1544 static void CredsManagerTest55(void)
1545 {
1546     CJson *json = CreateJson();
1547     Uint8Buff seedBuff = { nullptr, 0 };
1548     int32_t res = GetSeedValue(&seedBuff);
1549     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1550     HcFree(seedBuff.val);
1551     if (res != HC_SUCCESS) {
1552         FreeJson(json);
1553         return;
1554     }
1555     Uint8Buff presharedUrl = { nullptr, 0 };
1556     CJson *presharedUrlJson = CreateJson();
1557     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1558     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1559     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1560     FreeJson(presharedUrlJson);
1561     presharedUrl.val = (uint8_t *)presharedUrlStr;
1562     presharedUrl.length = strlen(presharedUrlStr) + 1;
1563     Uint8Buff sharedSecret = { nullptr, 0 };
1564     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1565     FreeJsonString(presharedUrlStr);
1566     FreeJson(json);
1567     if (res != HC_SUCCESS) {
1568         return;
1569     }
1570 }
1571 
CredsManagerTest56(void)1572 static void CredsManagerTest56(void)
1573 {
1574     CJson *json = CreateJson();
1575     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1576     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1577     Uint8Buff seedBuff = { nullptr, 0 };
1578     int32_t res = GetSeedValue(&seedBuff);
1579     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1580     HcFree(seedBuff.val);
1581     if (res != HC_SUCCESS) {
1582         FreeJson(json);
1583         return;
1584     }
1585     Uint8Buff presharedUrl = { nullptr, 0 };
1586     CJson *presharedUrlJson = CreateJson();
1587     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1588     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1589     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1590     FreeJson(presharedUrlJson);
1591     presharedUrl.val = (uint8_t *)presharedUrlStr;
1592     presharedUrl.length = strlen(presharedUrlStr) + 1;
1593     Uint8Buff sharedSecret = { nullptr, 0 };
1594     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1595     FreeJsonString(presharedUrlStr);
1596     FreeJson(json);
1597     if (res != HC_SUCCESS) {
1598         return;
1599     }
1600 }
1601 
CredsManagerTest57(void)1602 static void CredsManagerTest57(void)
1603 {
1604     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1605     AddDemoMember();
1606     CJson *json = CreateJson();
1607     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1608     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1609     Uint8Buff seedBuff = { nullptr, 0 };
1610     int32_t res = GetSeedValue(&seedBuff);
1611     AddByteToJson(json, FIELD_SEED, seedBuff.val, seedBuff.length);
1612     HcFree(seedBuff.val);
1613     if (res != HC_SUCCESS) {
1614         FreeJson(json);
1615         return;
1616     }
1617     Uint8Buff presharedUrl = { nullptr, 0 };
1618     CJson *presharedUrlJson = CreateJson();
1619     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1620     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1621     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1622     FreeJson(presharedUrlJson);
1623     presharedUrl.val = (uint8_t *)presharedUrlStr;
1624     presharedUrl.length = strlen(presharedUrlStr) + 1;
1625     Uint8Buff sharedSecret = { nullptr, 0 };
1626     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_ISO, &sharedSecret);
1627     FreeJsonString(presharedUrlStr);
1628     HcFree(sharedSecret.val);
1629     FreeJson(json);
1630     if (res != HC_SUCCESS) {
1631         return;
1632     }
1633 }
1634 
CredsManagerTest58(void)1635 static void CredsManagerTest58(void)
1636 {
1637     CJson *json = CreateJson();
1638     Uint8Buff presharedUrl = { nullptr, 0 };
1639     CJson *presharedUrlJson = CreateJson();
1640     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1641     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1642     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1643     FreeJson(presharedUrlJson);
1644     presharedUrl.val = (uint8_t *)presharedUrlStr;
1645     presharedUrl.length = strlen(presharedUrlStr) + 1;
1646     Uint8Buff sharedSecret = { nullptr, 0 };
1647     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1648     FreeJsonString(presharedUrlStr);
1649     FreeJson(json);
1650 }
1651 
CredsManagerTest59(void)1652 static void CredsManagerTest59(void)
1653 {
1654     CJson *json = CreateJson();
1655     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1656     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1657     Uint8Buff presharedUrl = { nullptr, 0 };
1658     CJson *presharedUrlJson = CreateJson();
1659     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1660     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1661     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1662     FreeJson(presharedUrlJson);
1663     presharedUrl.val = (uint8_t *)presharedUrlStr;
1664     presharedUrl.length = strlen(presharedUrlStr) + 1;
1665     Uint8Buff sharedSecret = { nullptr, 0 };
1666     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1667     FreeJsonString(presharedUrlStr);
1668     FreeJson(json);
1669 }
1670 
CredsManagerTest60(void)1671 static void CredsManagerTest60(void)
1672 {
1673     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1674     AddDemoMember();
1675     CJson *json = CreateJson();
1676     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1677     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1678     Uint8Buff presharedUrl = { nullptr, 0 };
1679     CJson *presharedUrlJson = CreateJson();
1680     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1681     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1682     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1683     FreeJson(presharedUrlJson);
1684     presharedUrl.val = (uint8_t *)presharedUrlStr;
1685     presharedUrl.length = strlen(presharedUrlStr) + 1;
1686     Uint8Buff sharedSecret = { nullptr, 0 };
1687     (void)GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1688     FreeJsonString(presharedUrlStr);
1689     FreeJson(json);
1690 }
1691 
CredsManagerTest61(void)1692 static void CredsManagerTest61(void)
1693 {
1694     CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID.c_str(), TEST_CREATE_PARAMS.c_str());
1695     AddDemoMember();
1696     CJson *json = CreateJson();
1697     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1698     AddStringToJson(json, FIELD_PEER_AUTH_ID, TEST_AUTH_ID2.c_str());
1699     Uint8Buff nonceBuff = { nullptr, 0 };
1700     int32_t res = GetNonceValue(&nonceBuff);
1701     AddByteToJson(json, FIELD_NONCE, nonceBuff.val, nonceBuff.length);
1702     HcFree(nonceBuff.val);
1703     if (res != HC_SUCCESS) {
1704         FreeJson(json);
1705         return;
1706     }
1707     Uint8Buff presharedUrl = { nullptr, 0 };
1708     CJson *presharedUrlJson = CreateJson();
1709     AddIntToJson(presharedUrlJson, PRESHARED_URL_TRUST_TYPE, TRUST_TYPE_P2P);
1710     AddStringToJson(presharedUrlJson, FIELD_GROUP_ID, TEST_GROUP_ID.c_str());
1711     char *presharedUrlStr = PackJsonToString(presharedUrlJson);
1712     FreeJson(presharedUrlJson);
1713     presharedUrl.val = (uint8_t *)presharedUrlStr;
1714     presharedUrl.length = strlen(presharedUrlStr) + 1;
1715     Uint8Buff sharedSecret = { nullptr, 0 };
1716     res = GetSharedSecretByUrl(json, &presharedUrl, ALG_EC_SPEKE, &sharedSecret);
1717     FreeJsonString(presharedUrlStr);
1718     HcFree(sharedSecret.val);
1719     FreeJson(json);
1720     if (res != HC_SUCCESS) {
1721         return;
1722     }
1723 }
1724 
CredsManagerTest62(void)1725 static void CredsManagerTest62(void)
1726 {
1727     int32_t res = GetSharedSecretByPeerCert(nullptr, nullptr, ALG_EC_SPEKE, nullptr);
1728     CJson *json = CreateJson();
1729     res = GetSharedSecretByPeerCert(json, nullptr, ALG_EC_SPEKE, nullptr);
1730     if (res != HC_SUCCESS) {
1731         FreeJson(json);
1732         return;
1733     }
1734     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1735     res = GetSharedSecretByPeerCert(json, &certInfo, ALG_EC_SPEKE, nullptr);
1736     if (res != HC_SUCCESS) {
1737         FreeJson(json);
1738         return;
1739     }
1740     Uint8Buff sharedSecret = { nullptr, 0 };
1741     res = GetSharedSecretByPeerCert(json, &certInfo, ALG_ISO, &sharedSecret);
1742     if (res != HC_SUCCESS) {
1743         FreeJson(json);
1744         return;
1745     }
1746     res = GetSharedSecretByPeerCert(json, &certInfo, ALG_EC_SPEKE, &sharedSecret);
1747     if (res != HC_SUCCESS) {
1748         FreeJson(json);
1749         return;
1750     }
1751     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1752     res = GetSharedSecretByPeerCert(json, &certInfo, ALG_EC_SPEKE, &sharedSecret);
1753     if (res != HC_SUCCESS) {
1754         FreeJson(json);
1755         return;
1756     }
1757     FreeJson(json);
1758 }
1759 
CredsManagerTest63(void)1760 static void CredsManagerTest63(void)
1761 {
1762     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
1763     CJson *json = CreateJson();
1764     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1765     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1766     CJson *pkInfoJson = CreateJson();
1767     AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_USER_ID.c_str());
1768     char *pkInfoStr = PackJsonToString(pkInfoJson);
1769     FreeJson(pkInfoJson);
1770     certInfo.pkInfoStr.val = (uint8_t *)pkInfoStr;
1771     certInfo.pkInfoStr.length = strlen(pkInfoStr) + 1;
1772     Uint8Buff sharedSecret = { nullptr, 0 };
1773     (void)GetSharedSecretByPeerCert(json, &certInfo, ALG_EC_SPEKE, &sharedSecret);
1774     FreeJsonString(pkInfoStr);
1775     FreeJson(json);
1776 }
1777 
CredsManagerTest64(void)1778 static void CredsManagerTest64(void)
1779 {
1780     CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM.c_str());
1781     SetDeviceStatus(false);
1782     CreateDemoIdenticalAccountGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_USER_ID.c_str(), TEST_REGISTER_INFO_PARAM2.c_str());
1783     SetDeviceStatus(true);
1784     CJson *json = CreateJson();
1785     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1786     CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1787     GetCertInfo(TEST_AUTH_OS_ACCOUNT_ID, TEST_USER_ID.c_str(), TEST_AUTH_ID2.c_str(), &certInfo);
1788     Uint8Buff sharedSecret = { nullptr, 0 };
1789     (void)GetSharedSecretByPeerCert(json, &certInfo, ALG_EC_SPEKE, &sharedSecret);
1790     HcFree(certInfo.pkInfoStr.val);
1791     HcFree(certInfo.pkInfoSignature.val);
1792     HcFree(sharedSecret.val);
1793     FreeJson(json);
1794 }
1795 
FuzzInnerPart1(void)1796 static void FuzzInnerPart1(void)
1797 {
1798     (void)CredsManagerTest01();
1799     (void)CredsManagerTest02();
1800     (void)CredsManagerTest03();
1801     (void)CredsManagerTest04();
1802     (void)CredsManagerTest05();
1803     (void)CredsManagerTest06();
1804     (void)CredsManagerTest07();
1805     (void)CredsManagerTest08();
1806     (void)CredsManagerTest09();
1807     (void)CredsManagerTest10();
1808     (void)CredsManagerTest11();
1809     (void)CredsManagerTest12();
1810     (void)CredsManagerTest13();
1811     (void)CredsManagerTest14();
1812     (void)CredsManagerTest15();
1813     (void)CredsManagerTest16();
1814     (void)CredsManagerTest17();
1815     (void)CredsManagerTest18();
1816     (void)CredsManagerTest19();
1817     (void)CredsManagerTest20();
1818     (void)CredsManagerTest21();
1819     (void)CredsManagerTest22();
1820     (void)CredsManagerTest23();
1821     (void)CredsManagerTest24();
1822     (void)CredsManagerTest25();
1823     (void)CredsManagerTest26();
1824     (void)CredsManagerTest27();
1825     (void)CredsManagerTest28();
1826     (void)CredsManagerTest29();
1827     (void)CredsManagerTest30();
1828     (void)CredsManagerTest31();
1829 }
1830 
FuzzInnerPart2(void)1831 static void FuzzInnerPart2(void)
1832 {
1833     (void)CredsManagerTest32();
1834     (void)CredsManagerTest33();
1835     (void)CredsManagerTest34();
1836     (void)CredsManagerTest35();
1837     (void)CredsManagerTest36();
1838     (void)CredsManagerTest37();
1839     (void)CredsManagerTest38();
1840     (void)CredsManagerTest39();
1841     (void)CredsManagerTest40();
1842     (void)CredsManagerTest41();
1843     (void)CredsManagerTest42();
1844     (void)CredsManagerTest43();
1845     (void)CredsManagerTest44();
1846     (void)CredsManagerTest45();
1847     (void)CredsManagerTest46();
1848     (void)CredsManagerTest47();
1849     (void)CredsManagerTest48();
1850     (void)CredsManagerTest49();
1851     (void)CredsManagerTest50();
1852     (void)CredsManagerTest51();
1853     (void)CredsManagerTest52();
1854     (void)CredsManagerTest53();
1855     (void)CredsManagerTest54();
1856     (void)CredsManagerTest55();
1857     (void)CredsManagerTest56();
1858     (void)CredsManagerTest57();
1859     (void)CredsManagerTest58();
1860     (void)CredsManagerTest59();
1861     (void)CredsManagerTest60();
1862     (void)CredsManagerTest61();
1863     (void)CredsManagerTest62();
1864     (void)CredsManagerTest63();
1865     (void)CredsManagerTest64();
1866 }
1867 
FuzzDoCallback(const uint8_t * data,size_t size)1868 bool FuzzDoCallback(const uint8_t* data, size_t size)
1869 {
1870     DeleteDatabase();
1871     InitDeviceAuthService();
1872     const DeviceGroupManager *gm = GetGmInstance();
1873     gm->regCallback(TEST_APP_ID.c_str(), &g_gmCallback);
1874     (void)data;
1875     (void)size;
1876     (void)FuzzInnerPart1();
1877     (void)FuzzInnerPart2();
1878     DestroyDeviceAuthService();
1879     return true;
1880 }
1881 }
1882 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1883 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1884 {
1885     /* Run your code on data */
1886     OHOS::FuzzDoCallback(data, size);
1887     return 0;
1888 }
1889 
1890