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