• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 "devauthfunc_fuzzer.h"
17 
18 #include <cstddef>
19 #include <cstdint>
20 #include <string>
21 
22 #include <cinttypes>
23 #include <unistd.h>
24 #include "account_module_defines.h"
25 #include "alg_loader.h"
26 #include "common_defs.h"
27 #include "device_auth.h"
28 #include "device_auth_defines.h"
29 #include "device_auth_ext.h"
30 #include "hc_dev_info_mock.h"
31 #include "json_utils_mock.h"
32 #include "json_utils.h"
33 #include "protocol_task_main_mock.h"
34 #include "securec.h"
35 #include "callback_manager.h"
36 
37 namespace OHOS {
38 #define TEST_DATA_LEN 0
39 #define TEST_APP_ID "TestAppId"
40 #define TEST_APP_ID2 "TestAppId2"
41 #define TEST_REQ_ID 123
42 #define TEST_REQ_ID2 321
43 #define TEST_REQ_ID3 132
44 #define TEST_REQ_ID4 213
45 #define TEST_GROUP_NAME "TestGroup"
46 #define TEST_AUTH_ID "TestAuthId"
47 #define TEST_AUTH_ID2 "TestAuthId2"
48 #define TEST_AUTH_ID3 "TestAuthId3"
49 #define TEST_UDID "TestUdid"
50 #define TEST_UDID2 "TestUdid2"
51 #define TEST_QUERY_PARAMS "bac"
52 #define TEST_PIN_CODE "123456"
53 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
54 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
55 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
56 #define TEST_GROUP_ID2 "F2AA208B1E010542B20A34B03B4B6289EA7C7F6DFE97DA2E370348B826682D3D"
57 #define TEST_GROUP_ID3 "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
58 #define TEST_GROUP_ID4 "6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F"
59 #define TEST_USER_ID_AUTH "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
60 #define TEST_USER_ID "4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4"
61 #define TEST_AUTH_CODE "37364761534f454d33567a73424e794f33573330507069434b31676f7254706b"
62 #define TEST_AUTH_CODE2 "2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335"
63 #define TEST_AUTH_CODE3 "1234567812345678123456781234567812345678123456781234567812345678"
64 #define TEST_AUTH_TOKEN3 "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92"
65 #define TEST_DEV_AUTH_SLEEP_TIME 50000
66 #define TEST_DEV_AUTH_SLEEP_TIME2 600000
67 #define TEST_TRANSMIT_DATA_LEN 2048
68 #define TEST_HKS_MAIN_DATA_PATH "/data/service/el1/public/huks_service/tmp/+0+0+0+0"
69 #define TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN 32
70 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
71 static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
72 static const char *CREATE_PARAMS = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
73     "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
74 static const char *CREATE_PARAMS2 = "{\"groupType\":1282,\"userId\":\"4269DC28B639681698809A67EDAD08E39F20790"
75     "0038F91FEF95DD042FE2874E4\",\"peerUserId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\"}";
76 static const char *DISBAND_PARAMS =
77     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\"}";
78 static const char *DISBAND_PARAMS2 =
79     "{\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
80 static const char *DISBAND_PARAMS3 =
81     "{\"groupId\":\"FF52352E8082CE2B34DEF7A55F40BA694F64D5200ADA86686B862772F3517A84\"}";
82 static const char *ADD_PARAMS =
83     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
84     "\"groupType\":256,\"pinCode\":\"123456\"}";
85 static const char *AUTH_PARAMS = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
86     "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
87 static const char *ADD_MULTI_PARAMS =
88     "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
89     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\",\"udid\":\"TestUdid2\","
90     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
91     "\"credential\":{\"credentialType\":1,"
92     "\"authCode\":\"37364761534f454d33567a73424e794f33573330507069434b31676f7254706b\"}},"
93     "{\"deviceId\":\"TestAuthId3\",\"udid\":\"TestUdid3\","
94     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
95     "\"credential\":{\"credentialType\":1,"
96     "\"authCode\":\"2f7562744654535564586e665467546b322b4b506b65626373466f48766a4335\"}}]}";
97 static const char *DEL_MULTI_PARAMS =
98     "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
99     "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
100 static const char *DELETE_PARAMS =
101     "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"TestAuthId2\"}";
102 static const char *GET_REGISTER_INFO_PARAMS =
103     "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\","
104     "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
105 static const char *QUERY_PARAMS = "{\"groupOwner\":\"TestAppId\"}";
106 static const char *QUERY_PK_PARAMS = "{\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD"
107     "2E6492C\",\"isSelfPk\":true}";
108 static const char *QUERY_PK_PARAMS2 = "{\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD"
109     "2E6492C\",\"isSelfPk\":false}";
110 
111 enum AsyncStatus {
112     ASYNC_STATUS_WAITING = 0,
113     ASYNC_STATUS_TRANSMIT = 1,
114     ASYNC_STATUS_FINISH = 2,
115     ASYNC_STATUS_ERROR = 3
116 };
117 
118 static AsyncStatus volatile g_asyncStatus;
119 static uint8_t g_transmitData[2048] = { 0 };
120 static uint32_t g_transmitDataLen = 0;
121 
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)122 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
123 {
124     if (memcpy_s(g_transmitData, TEST_TRANSMIT_DATA_LEN, data, dataLen) != EOK) {
125         return false;
126     }
127     g_transmitDataLen = dataLen;
128     g_asyncStatus = ASYNC_STATUS_TRANSMIT;
129     return true;
130 }
131 
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)132 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
133 {
134     (void)requestId;
135     (void)sessionKey;
136     (void)sessionKeyLen;
137     return;
138 }
139 
OnFinish(int64_t requestId,int operationCode,const char * authReturn)140 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
141 {
142     g_asyncStatus = ASYNC_STATUS_FINISH;
143 }
144 
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)145 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
146 {
147     g_asyncStatus = ASYNC_STATUS_ERROR;
148 }
149 
OnBindRequest(int64_t requestId,int operationCode,const char * reqParam)150 static char *OnBindRequest(int64_t requestId, int operationCode, const char* reqParam)
151 {
152     CJson *json = CreateJson();
153     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
154     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
155     AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
156     AddStringToJson(json, FIELD_DEVICE_ID, TEST_AUTH_ID2);
157     char *returnDataStr = PackJsonToString(json);
158     FreeJson(json);
159     return returnDataStr;
160 }
161 
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)162 static char *OnAuthRequest(int64_t requestId, int operationCode, const char* reqParam)
163 {
164     CJson *json = CreateJson();
165     AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
166     AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
167     AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
168     AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID);
169     char *returnDataStr = PackJsonToString(json);
170     FreeJson(json);
171     return returnDataStr;
172 }
173 
174 static DeviceAuthCallback g_gmCallback = {
175     .onTransmit = OnTransmit,
176     .onSessionKeyReturned = OnSessionKeyReturned,
177     .onFinish = OnFinish,
178     .onError = OnError,
179     .onRequest = OnBindRequest
180 };
181 
182 static DeviceAuthCallback g_gaCallback = {
183     .onTransmit = OnTransmit,
184     .onSessionKeyReturned = OnSessionKeyReturned,
185     .onFinish = OnFinish,
186     .onError = OnError,
187     .onRequest = OnAuthRequest
188 };
189 
OnGroupCreated(const char * groupInfo)190 static void OnGroupCreated(const char *groupInfo) {}
191 
OnGroupDeleted(const char * groupInfo)192 static void OnGroupDeleted(const char *groupInfo) {}
193 
OnDeviceBound(const char * peerUdid,const char * groupInfo)194 static void OnDeviceBound(const char *peerUdid, const char* groupInfo) {}
195 
OnDeviceUnBound(const char * peerUdid,const char * groupInfo)196 static void OnDeviceUnBound(const char *peerUdid, const char* groupInfo) {}
197 
OnDeviceNotTrusted(const char * peerUdid)198 static void OnDeviceNotTrusted(const char *peerUdid) {}
199 
OnLastGroupDeleted(const char * peerUdid,int groupType)200 static void OnLastGroupDeleted(const char *peerUdid, int groupType) {}
201 
OnTrustedDeviceNumChanged(int curTrustedDeviceNum)202 static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum) {}
203 
204 static DataChangeListener g_listener = {
205     .onGroupCreated = OnGroupCreated,
206     .onGroupDeleted = OnGroupDeleted,
207     .onDeviceBound = OnDeviceBound,
208     .onDeviceUnBound = OnDeviceUnBound,
209     .onDeviceNotTrusted = OnDeviceNotTrusted,
210     .onLastGroupDeleted = OnLastGroupDeleted,
211     .onTrustedDeviceNumChanged = OnTrustedDeviceNumChanged
212 };
213 
RemoveDir(const char * path)214 static void RemoveDir(const char *path)
215 {
216     char strBuf[TEST_DEV_AUTH_BUFFER_SIZE] = {0};
217     if (path == nullptr) {
218         return;
219     }
220     if (sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path) < 0) {
221         return;
222     }
223     system(strBuf);
224     return;
225 }
226 
DeleteDatabase()227 static void DeleteDatabase()
228 {
229     const char *groupPath = "/data/service/el1/public/deviceauthMock";
230     RemoveDir(groupPath);
231     RemoveDir(TEST_HKS_MAIN_DATA_PATH);
232     return;
233 }
234 
GenerateTempKeyPair(const Uint8Buff * keyAlias)235 static int32_t GenerateTempKeyPair(const Uint8Buff *keyAlias)
236 {
237     int32_t ret = GetLoaderInstance()->checkKeyExist(keyAlias, false, DEFAULT_OS_ACCOUNT);
238     if (ret != HC_SUCCESS) {
239         int32_t authId = 0;
240         Uint8Buff authIdBuff = { reinterpret_cast<uint8_t *>(&authId), sizeof(int32_t)};
241         ExtraInfo extInfo = {authIdBuff, -1, -1};
242         KeyParams keyParams = { { keyAlias->val, keyAlias->length, true }, false, DEFAULT_OS_ACCOUNT };
243         ret = GetLoaderInstance()->generateKeyPairWithStorage(&keyParams, TEST_DEV_AUTH_TEMP_KEY_PAIR_LEN, P256,
244             KEY_PURPOSE_SIGN_VERIFY, &extInfo);
245     }
246     return ret;
247 }
248 
GetAsyCredentialJson(const std::string registerInfo)249 static CJson *GetAsyCredentialJson(const std::string registerInfo)
250 {
251     uint8_t keyAliasValue[] = "TestServerKeyPair";
252     int32_t keyAliasLen = 18;
253     Uint8Buff keyAlias = {
254         .val = keyAliasValue,
255         .length = keyAliasLen
256     };
257     if (GenerateTempKeyPair(&keyAlias) != HC_SUCCESS) {
258         return nullptr;
259     }
260     uint8_t *serverPkVal = reinterpret_cast<uint8_t *>(HcMalloc(SERVER_PK_SIZE, 0));
261     Uint8Buff serverPk = {
262         .val = serverPkVal,
263         .length = SERVER_PK_SIZE
264     };
265 
266     KeyParams keyAliasParams = { { keyAlias.val, keyAlias.length, true }, false, DEFAULT_OS_ACCOUNT };
267     int32_t ret = GetLoaderInstance()->exportPublicKey(&keyAliasParams, &serverPk);
268     if (ret != HC_SUCCESS) {
269         HcFree(serverPkVal);
270         return nullptr;
271     }
272 
273     Uint8Buff messageBuff = {
274         .val = reinterpret_cast<uint8_t *>(const_cast<char *>(registerInfo.c_str())),
275         .length = registerInfo.length() + 1
276     };
277     uint8_t *signatureValue = reinterpret_cast<uint8_t *>(HcMalloc(SIGNATURE_SIZE, 0));
278     Uint8Buff signature = {
279         .val = signatureValue,
280         .length = SIGNATURE_SIZE
281     };
282     ret = GetLoaderInstance()->sign(&keyAliasParams, &messageBuff, P256, &signature);
283     if (ret != HC_SUCCESS) {
284         HcFree(serverPkVal);
285         HcFree(signatureValue);
286         return nullptr;
287     }
288 
289     CJson *pkInfoJson = CreateJsonFromString(registerInfo.c_str());
290     CJson *credentialJson = CreateJson();
291     (void)AddIntToJson(credentialJson, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
292     (void)AddByteToJson(credentialJson, FIELD_SERVER_PK, serverPkVal, serverPk.length);
293     (void)AddByteToJson(credentialJson, FIELD_PK_INFO_SIGNATURE, signatureValue, signature.length);
294     (void)AddObjToJson(credentialJson, FIELD_PK_INFO, pkInfoJson);
295     FreeJson(pkInfoJson);
296     return credentialJson;
297 }
298 
CreateDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * createParams)299 static int32_t CreateDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId, const char *createParams)
300 {
301     g_asyncStatus = ASYNC_STATUS_WAITING;
302     const DeviceGroupManager *gm = GetGmInstance();
303     if (gm == nullptr) {
304         return HC_ERR_NULL_PTR;
305     }
306     int32_t ret = gm->createGroup(osAccountId, reqId, appId, createParams);
307     if (ret != HC_SUCCESS) {
308         g_asyncStatus = ASYNC_STATUS_ERROR;
309         return ret;
310     }
311     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
312         usleep(TEST_DEV_AUTH_SLEEP_TIME);
313     }
314     usleep(TEST_DEV_AUTH_SLEEP_TIME);
315     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
316 }
317 
CreateDemoIdenticalAccountGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * userId)318 static int32_t CreateDemoIdenticalAccountGroup(int32_t osAccountId, int64_t reqId,
319     const char *appId, const char *userId)
320 {
321     g_asyncStatus = ASYNC_STATUS_WAITING;
322     const DeviceGroupManager *gm = GetGmInstance();
323     if (gm == nullptr) {
324         return HC_ERR_NULL_PTR;
325     }
326     char *returnData = nullptr;
327     int32_t ret = gm->getRegisterInfo(GET_REGISTER_INFO_PARAMS, &returnData);
328     if (ret != HC_SUCCESS) {
329         return ret;
330     }
331     std::string registerInfo(returnData);
332     CJson *credJson = GetAsyCredentialJson(registerInfo);
333     if (ret != HC_SUCCESS) {
334         gm->destroyInfo(&returnData);
335         return ret;
336     }
337     CJson *json = CreateJson();
338     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
339     AddStringToJson(json, FIELD_USER_ID, userId);
340     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
341     char *jsonStr = PackJsonToString(json);
342     FreeJson(credJson);
343     FreeJson(json);
344     gm->destroyInfo(&returnData);
345     ret = gm->createGroup(osAccountId, reqId, appId, jsonStr);
346     FreeJsonString(jsonStr);
347     if (ret != HC_SUCCESS) {
348         return ret;
349     }
350     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
351         usleep(TEST_DEV_AUTH_SLEEP_TIME);
352     }
353     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
354 }
355 
CreateDemoSymIdenticalAccountGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * userId)356 static int32_t CreateDemoSymIdenticalAccountGroup(int32_t osAccountId, int64_t reqId,
357     const char *appId, const char *userId)
358 {
359     g_asyncStatus = ASYNC_STATUS_WAITING;
360     const DeviceGroupManager *gm = GetGmInstance();
361     if (gm == nullptr) {
362         return HC_ERR_NULL_PTR;
363     }
364 
365     CJson *credJson = CreateJson();
366     (void)AddIntToJson(credJson, FIELD_CREDENTIAL_TYPE, SYMMETRIC_CRED);
367     (void)AddStringToJson(credJson, FIELD_AUTH_CODE, TEST_AUTH_CODE);
368     CJson *json = CreateJson();
369     AddIntToJson(json, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
370     AddStringToJson(json, FIELD_USER_ID, userId);
371     AddObjToJson(json, FIELD_CREDENTIAL, credJson);
372     char *jsonStr = PackJsonToString(json);
373     FreeJson(credJson);
374     FreeJson(json);
375     if (jsonStr == nullptr) {
376         return HC_ERR_NULL_PTR;
377     }
378     int32_t ret = gm->createGroup(osAccountId, reqId, appId, jsonStr);
379     FreeJsonString(jsonStr);
380     if (ret != HC_SUCCESS) {
381         return ret;
382     }
383     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
384         usleep(TEST_DEV_AUTH_SLEEP_TIME);
385     }
386     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
387 }
388 
DeleteDemoGroup(int32_t osAccountId,int64_t reqId,const char * appId,const char * disbandParams)389 static int32_t DeleteDemoGroup(int32_t osAccountId, int64_t reqId, const char *appId,
390     const char *disbandParams)
391 {
392     g_asyncStatus = ASYNC_STATUS_WAITING;
393     const DeviceGroupManager *gm = GetGmInstance();
394     if (gm == nullptr) {
395         return HC_ERR_NULL_PTR;
396     }
397     int32_t ret = gm->deleteGroup(osAccountId, reqId, appId, disbandParams);
398     if (ret != HC_SUCCESS) {
399         return ret;
400     }
401     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
402         usleep(TEST_DEV_AUTH_SLEEP_TIME);
403     }
404     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
405 }
406 
AddDemoMember(void)407 static int32_t AddDemoMember(void)
408 {
409     g_asyncStatus = ASYNC_STATUS_WAITING;
410     bool isClient = true;
411     SetDeviceStatus(isClient);
412     const DeviceGroupManager *gm = GetGmInstance();
413     if (gm == nullptr) {
414         return HC_ERR_NULL_PTR;
415     }
416     int32_t ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
417     if (ret != HC_SUCCESS) {
418         g_asyncStatus = ASYNC_STATUS_ERROR;
419         return ret;
420     }
421     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
422         usleep(TEST_DEV_AUTH_SLEEP_TIME);
423     }
424     while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
425         isClient = !isClient;
426         SetDeviceStatus(isClient);
427         g_asyncStatus = ASYNC_STATUS_WAITING;
428         if (isClient) {
429             ret = gm->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen);
430         } else {
431             ret = gm->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen);
432         }
433         (void)memset_s(g_transmitData, TEST_TRANSMIT_DATA_LEN, 0, TEST_TRANSMIT_DATA_LEN);
434         g_transmitDataLen = 0;
435         if (ret != HC_SUCCESS) {
436             g_asyncStatus = ASYNC_STATUS_ERROR;
437             return ret;
438         }
439         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
440             usleep(TEST_DEV_AUTH_SLEEP_TIME);
441         }
442         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
443             break;
444         }
445         if (g_transmitDataLen > 0) {
446             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
447         }
448     }
449     usleep(TEST_DEV_AUTH_SLEEP_TIME2);
450     SetDeviceStatus(true);
451     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
452 }
453 
AuthDemoMember(void)454 static int32_t AuthDemoMember(void)
455 {
456     g_asyncStatus = ASYNC_STATUS_WAITING;
457     bool isClient = true;
458     SetDeviceStatus(isClient);
459     const GroupAuthManager *ga = GetGaInstance();
460     if (ga == nullptr) {
461         return HC_ERR_NULL_PTR;
462     }
463     int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID3, AUTH_PARAMS, &g_gaCallback);
464     if (ret != HC_SUCCESS) {
465         g_asyncStatus = ASYNC_STATUS_ERROR;
466         return ret;
467     }
468     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
469         usleep(TEST_DEV_AUTH_SLEEP_TIME);
470     }
471     while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
472         isClient = !isClient;
473         SetDeviceStatus(isClient);
474         g_asyncStatus = ASYNC_STATUS_WAITING;
475         if (isClient) {
476             ret = ga->processData(TEST_REQ_ID3, g_transmitData, g_transmitDataLen, &g_gaCallback);
477         } else {
478             ret = ga->processData(TEST_REQ_ID4, g_transmitData, g_transmitDataLen, &g_gaCallback);
479         }
480         (void)memset_s(g_transmitData, TEST_TRANSMIT_DATA_LEN, 0, TEST_TRANSMIT_DATA_LEN);
481         g_transmitDataLen = 0;
482         if (ret != HC_SUCCESS) {
483             g_asyncStatus = ASYNC_STATUS_ERROR;
484             return ret;
485         }
486         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
487             usleep(TEST_DEV_AUTH_SLEEP_TIME);
488         }
489         if (g_asyncStatus == ASYNC_STATUS_ERROR) {
490             break;
491         }
492         if (g_transmitDataLen > 0) {
493             g_asyncStatus = ASYNC_STATUS_TRANSMIT;
494         }
495     }
496     SetDeviceStatus(true);
497     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
498 }
499 
DelDemoMember(int32_t osAccountId,int64_t reqId,const char * appId,const char * deleteParams)500 static int32_t DelDemoMember(int32_t osAccountId, int64_t reqId, const char *appId,
501     const char *deleteParams)
502 {
503     g_asyncStatus = ASYNC_STATUS_WAITING;
504     const DeviceGroupManager *gm = GetGmInstance();
505     if (gm == nullptr) {
506         return HC_ERR_NULL_PTR;
507     }
508     int32_t ret = gm->deleteMemberFromGroup(osAccountId, reqId, appId, deleteParams);
509     if (ret != HC_SUCCESS) {
510         return ret;
511     }
512     while (g_asyncStatus == ASYNC_STATUS_WAITING) {
513         usleep(TEST_DEV_AUTH_SLEEP_TIME);
514     }
515     return g_asyncStatus == ASYNC_STATUS_ERROR ? HC_ERROR : HC_SUCCESS;
516 }
517 
DevAuthTestCase004(void)518 static int32_t DevAuthTestCase004(void)
519 {
520     DeleteDatabase();
521     int32_t ret = InitDeviceAuthService();
522     if (ret != HC_SUCCESS) {
523         return ret;
524     }
525     do {
526         const DeviceGroupManager *gm = GetGmInstance();
527         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
528         if (ret != HC_SUCCESS) {
529             break;
530         }
531         ret = gm->unRegCallback(TEST_APP_ID);
532     } while (0);
533     DestroyDeviceAuthService();
534     return ret;
535 }
536 
DevAuthTestCase005(void)537 static int32_t DevAuthTestCase005(void)
538 {
539     DeleteDatabase();
540     int32_t ret = InitDeviceAuthService();
541     if (ret != HC_SUCCESS) {
542         return ret;
543     }
544     do {
545         const DeviceGroupManager *gm = GetGmInstance();
546         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
547         if (ret != HC_SUCCESS) {
548             break;
549         }
550         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
551     } while (0);
552     DestroyDeviceAuthService();
553     return ret;
554 }
555 
DevAuthTestCase006(void)556 static int32_t DevAuthTestCase006(void)
557 {
558     DeleteDatabase();
559     int32_t ret = InitDeviceAuthService();
560     if (ret != HC_SUCCESS) {
561         return ret;
562     }
563     do {
564         const DeviceGroupManager *gm = GetGmInstance();
565         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
566         if (ret != HC_SUCCESS) {
567             break;
568         }
569         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
570         if (ret != HC_SUCCESS) {
571             break;
572         }
573         ret = AddDemoMember();
574     } while (0);
575     DestroyDeviceAuthService();
576     return ret;
577 }
578 
DevAuthTestCase007(void)579 static int32_t DevAuthTestCase007(void)
580 {
581     DeleteDatabase();
582     int32_t ret = InitDeviceAuthService();
583     if (ret != HC_SUCCESS) {
584         return ret;
585     }
586     do {
587         const DeviceGroupManager *gm = GetGmInstance();
588         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
589         if (ret != HC_SUCCESS) {
590             break;
591         }
592         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
593         if (ret != HC_SUCCESS) {
594             break;
595         }
596         ret = AddDemoMember();
597         if (ret != HC_SUCCESS) {
598             break;
599         }
600         ret = AuthDemoMember();
601     } while (0);
602     DestroyDeviceAuthService();
603     return ret;
604 }
605 
DevAuthTestCase008(void)606 static int32_t DevAuthTestCase008(void)
607 {
608     DeleteDatabase();
609     int32_t ret = InitDeviceAuthService();
610     if (ret != HC_SUCCESS) {
611         return ret;
612     }
613     do {
614         const DeviceGroupManager *gm = GetGmInstance();
615         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
616         if (ret != HC_SUCCESS) {
617             break;
618         }
619         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
620         if (ret != HC_SUCCESS) {
621             break;
622         }
623         ret = AddDemoMember();
624         if (ret != HC_SUCCESS) {
625             break;
626         }
627         ret = DelDemoMember(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DELETE_PARAMS);
628     } while (0);
629     DestroyDeviceAuthService();
630     return ret;
631 }
632 
DevAuthTestCase009(void)633 static int32_t DevAuthTestCase009(void)
634 {
635     DeleteDatabase();
636     int32_t ret = InitDeviceAuthService();
637     if (ret != HC_SUCCESS) {
638         return ret;
639     }
640     do {
641         const DeviceGroupManager *gm = GetGmInstance();
642         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
643         if (ret != HC_SUCCESS) {
644             break;
645         }
646         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
647         if (ret != HC_SUCCESS) {
648             break;
649         }
650         ret = DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS);
651     } while (0);
652     DestroyDeviceAuthService();
653     return ret;
654 }
655 
DevAuthTestCase010(void)656 static int32_t DevAuthTestCase010(void)
657 {
658     DeleteDatabase();
659     int32_t ret = InitDeviceAuthService();
660     if (ret != HC_SUCCESS) {
661         return ret;
662     }
663     do {
664         char *returnData = nullptr;
665         ret = GetGmInstance()->getRegisterInfo(GET_REGISTER_INFO_PARAMS, &returnData);
666         if (ret != HC_SUCCESS) {
667             break;
668         }
669         if (returnData == nullptr) {
670             ret = HC_ERROR;
671         }
672     } while (0);
673     DestroyDeviceAuthService();
674     return ret;
675 }
676 
DevAuthTestCase011(void)677 static int32_t DevAuthTestCase011(void)
678 {
679     DeleteDatabase();
680     int32_t ret = InitDeviceAuthService();
681     if (ret != HC_SUCCESS) {
682         return ret;
683     }
684     do {
685         const DeviceGroupManager *gm = GetGmInstance();
686         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
687         if (ret != HC_SUCCESS) {
688             break;
689         }
690         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
691     } while (0);
692     DestroyDeviceAuthService();
693     return ret;
694 }
695 
DevAuthTestCase012(void)696 static int32_t DevAuthTestCase012(void)
697 {
698     DeleteDatabase();
699     int32_t ret = InitDeviceAuthService();
700     if (ret != HC_SUCCESS) {
701         return ret;
702     }
703     do {
704         const DeviceGroupManager *gm = GetGmInstance();
705         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
706         if (ret != HC_SUCCESS) {
707             break;
708         }
709         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
710         if (ret != HC_SUCCESS) {
711             break;
712         }
713         ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_MULTI_PARAMS);
714     } while (0);
715     DestroyDeviceAuthService();
716     return ret;
717 }
718 
DevAuthTestCase013(void)719 static int32_t DevAuthTestCase013(void)
720 {
721     DeleteDatabase();
722     SetDeviceStatus(true);
723     int32_t ret = InitDeviceAuthService();
724     if (ret != HC_SUCCESS) {
725         return ret;
726     }
727     DestroyDeviceAuthService();
728     SetDeviceStatus(false);
729     ret = InitDeviceAuthService();
730     if (ret != HC_SUCCESS) {
731         return ret;
732     }
733     DestroyDeviceAuthService();
734     SetDeviceStatus(true);
735     ret = InitDeviceAuthService();
736     if (ret != HC_SUCCESS) {
737         return ret;
738     }
739     do {
740         const DeviceGroupManager *gm = GetGmInstance();
741         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
742         if (ret != HC_SUCCESS) {
743             break;
744         }
745         SetDeviceStatus(true);
746         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
747         if (ret != HC_SUCCESS) {
748             break;
749         }
750         SetDeviceStatus(false);
751         ret = CreateDemoIdenticalAccountGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
752         if (ret != HC_SUCCESS) {
753             break;
754         }
755         ret = AuthDemoMember();
756     } while (0);
757     DestroyDeviceAuthService();
758     return ret;
759 }
760 
DevAuthTestCase014(void)761 static int32_t DevAuthTestCase014(void)
762 {
763     DeleteDatabase();
764     int32_t ret = InitDeviceAuthService();
765     if (ret != HC_SUCCESS) {
766         return ret;
767     }
768     do {
769         const DeviceGroupManager *gm = GetGmInstance();
770         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
771         if (ret != HC_SUCCESS) {
772             break;
773         }
774         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
775         if (ret != HC_SUCCESS) {
776             break;
777         }
778         ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_MULTI_PARAMS);
779         if (ret != HC_SUCCESS) {
780             break;
781         }
782         ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, DEL_MULTI_PARAMS);
783     } while (0);
784     DestroyDeviceAuthService();
785     return ret;
786 }
787 
DevAuthTestCase015(void)788 static int32_t DevAuthTestCase015(void)
789 {
790     DeleteDatabase();
791     int32_t ret = InitDeviceAuthService();
792     if (ret != HC_SUCCESS) {
793         return ret;
794     }
795     do {
796         const DeviceGroupManager *gm = GetGmInstance();
797         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
798         if (ret != HC_SUCCESS) {
799             break;
800         }
801         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
802         if (ret != HC_SUCCESS) {
803             break;
804         }
805         ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_MULTI_PARAMS);
806         if (ret != HC_SUCCESS) {
807             break;
808         }
809         ret = DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS2);
810     } while (0);
811     DestroyDeviceAuthService();
812     return ret;
813 }
814 
DevAuthTestCase016(void)815 static int32_t DevAuthTestCase016(void)
816 {
817     DeleteDatabase();
818     int32_t ret = InitDeviceAuthService();
819     if (ret != HC_SUCCESS) {
820         return ret;
821     }
822     do {
823         const DeviceGroupManager *gm = GetGmInstance();
824         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
825         if (ret != HC_SUCCESS) {
826             break;
827         }
828         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
829         if (ret != HC_SUCCESS) {
830             break;
831         }
832         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS2);
833     } while (0);
834     DestroyDeviceAuthService();
835     return ret;
836 }
837 
DevAuthTestCase018(void)838 static int32_t DevAuthTestCase018(void)
839 {
840     DeleteDatabase();
841     int32_t ret = InitDeviceAuthService();
842     if (ret != HC_SUCCESS) {
843         return ret;
844     }
845     do {
846         const DeviceGroupManager *gm = GetGmInstance();
847         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
848         if (ret != HC_SUCCESS) {
849             break;
850         }
851         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
852         if (ret != HC_SUCCESS) {
853             break;
854         }
855         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS2);
856         if (ret != HC_SUCCESS) {
857             break;
858         }
859         ret = DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS3);
860     } while (0);
861     DestroyDeviceAuthService();
862     return ret;
863 }
864 
DevAuthTestCase019(void)865 static int32_t DevAuthTestCase019(void)
866 {
867     DeleteDatabase();
868     int32_t ret = InitDeviceAuthService();
869     if (ret != HC_SUCCESS) {
870         return ret;
871     }
872     do {
873         const DeviceGroupManager *gm = GetGmInstance();
874         ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
875     } while (0);
876     DestroyDeviceAuthService();
877     return ret;
878 }
879 
DevAuthTestCase020(void)880 static int32_t DevAuthTestCase020(void)
881 {
882     DeleteDatabase();
883     int32_t ret = InitDeviceAuthService();
884     if (ret != HC_SUCCESS) {
885         return ret;
886     }
887     do {
888         const DeviceGroupManager *gm = GetGmInstance();
889         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
890         if (ret != HC_SUCCESS) {
891             break;
892         }
893         ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
894         if (ret != HC_SUCCESS) {
895             break;
896         }
897         ret = CreateDemoIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
898         if (ret != HC_SUCCESS) {
899             break;
900         }
901         ret = gm->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, ADD_MULTI_PARAMS);
902         if (ret != HC_SUCCESS) {
903             break;
904         }
905         ret = gm->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, DEL_MULTI_PARAMS);
906         if (ret != HC_SUCCESS) {
907             break;
908         }
909         ret = DeleteDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, DISBAND_PARAMS2);
910     } while (0);
911     DestroyDeviceAuthService();
912     return ret;
913 }
914 
DevAuthTestCase021(void)915 static int32_t DevAuthTestCase021(void)
916 {
917     DeleteDatabase();
918     int32_t ret = InitDeviceAuthService();
919     if (ret != HC_SUCCESS) {
920         return ret;
921     }
922     do {
923         const DeviceGroupManager *gm = GetGmInstance();
924         ret = gm->regDataChangeListener(TEST_APP_ID, &g_listener);
925         if (ret != HC_SUCCESS) {
926             break;
927         }
928         ret = gm->unRegDataChangeListener(TEST_APP_ID);
929     } while (0);
930     DestroyDeviceAuthService();
931     return ret;
932 }
933 
DevAuthTestCase022(void)934 static int32_t DevAuthTestCase022(void)
935 {
936     DeleteDatabase();
937     int32_t ret = InitDeviceAuthService();
938     if (ret != HC_SUCCESS) {
939         return ret;
940     }
941     do {
942         const DeviceGroupManager *gm = GetGmInstance();
943         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
944         if (ret != HC_SUCCESS) {
945             break;
946         }
947         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
948         if (ret != HC_SUCCESS) {
949             break;
950         }
951         ret = gm->checkAccessToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID);
952     } while (0);
953     DestroyDeviceAuthService();
954     return ret;
955 }
956 
DevAuthTestCase023(void)957 static int32_t DevAuthTestCase023(void)
958 {
959     DeleteDatabase();
960     int32_t ret = InitDeviceAuthService();
961     if (ret != HC_SUCCESS) {
962         return ret;
963     }
964     do {
965         const DeviceGroupManager *gm = GetGmInstance();
966         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
967         if (ret != HC_SUCCESS) {
968             break;
969         }
970         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
971         if (ret != HC_SUCCESS) {
972             break;
973         }
974         char* returnRes = nullptr;
975         ret = gm->getGroupInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnRes);
976         if (ret != HC_SUCCESS || returnRes == nullptr) {
977             ret = HC_ERROR;
978         }
979     } while (0);
980     DestroyDeviceAuthService();
981     return ret;
982 }
983 
DevAuthTestCase024(void)984 static int32_t DevAuthTestCase024(void)
985 {
986     DeleteDatabase();
987     int32_t ret = InitDeviceAuthService();
988     if (ret != HC_SUCCESS) {
989         return ret;
990     }
991     do {
992         const DeviceGroupManager *gm = GetGmInstance();
993         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
994         if (ret != HC_SUCCESS) {
995             break;
996         }
997         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
998         if (ret != HC_SUCCESS) {
999             break;
1000         }
1001         uint32_t returnNum = 0;
1002         char* returnRes = nullptr;
1003         ret = gm->getGroupInfo(DEFAULT_OS_ACCOUNT, TEST_APP_ID, QUERY_PARAMS, &returnRes, &returnNum);
1004         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1005             ret = HC_ERROR;
1006         }
1007     } while (0);
1008     DestroyDeviceAuthService();
1009     return ret;
1010 }
1011 
DevAuthTestCase025(void)1012 static int32_t DevAuthTestCase025(void)
1013 {
1014     DeleteDatabase();
1015     int32_t ret = InitDeviceAuthService();
1016     if (ret != HC_SUCCESS) {
1017         return ret;
1018     }
1019     do {
1020         const DeviceGroupManager *gm = GetGmInstance();
1021         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1022         if (ret != HC_SUCCESS) {
1023             break;
1024         }
1025         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1026         if (ret != HC_SUCCESS) {
1027             break;
1028         }
1029         uint32_t returnNum = 0;
1030         char* returnRes = nullptr;
1031         ret = gm->getJoinedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, PEER_TO_PEER_GROUP, &returnRes, &returnNum);
1032         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1033             ret = HC_ERROR;
1034         }
1035     } while (0);
1036     DestroyDeviceAuthService();
1037     return ret;
1038 }
1039 
DevAuthTestCase026(void)1040 static int32_t DevAuthTestCase026(void)
1041 {
1042     DeleteDatabase();
1043     int32_t ret = InitDeviceAuthService();
1044     if (ret != HC_SUCCESS) {
1045         return ret;
1046     }
1047     do {
1048         const DeviceGroupManager *gm = GetGmInstance();
1049         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1050         if (ret != HC_SUCCESS) {
1051             break;
1052         }
1053         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1054         if (ret != HC_SUCCESS) {
1055             break;
1056         }
1057         uint32_t returnNum = 0;
1058         char* returnRes = nullptr;
1059         ret = gm->getRelatedGroups(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, &returnRes, &returnNum);
1060         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1061             ret = HC_ERROR;
1062         }
1063     } while (0);
1064     DestroyDeviceAuthService();
1065     return ret;
1066 }
1067 
DevAuthTestCase027(void)1068 static int32_t DevAuthTestCase027(void)
1069 {
1070     DeleteDatabase();
1071     int32_t ret = InitDeviceAuthService();
1072     if (ret != HC_SUCCESS) {
1073         return ret;
1074     }
1075     do {
1076         const DeviceGroupManager *gm = GetGmInstance();
1077         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1078         if (ret != HC_SUCCESS) {
1079             break;
1080         }
1081         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1082         if (ret != HC_SUCCESS) {
1083             break;
1084         }
1085         char* returnRes = nullptr;
1086         ret = gm->getDeviceInfoById(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_AUTH_ID, TEST_GROUP_ID, &returnRes);
1087         if (ret != HC_SUCCESS || returnRes == nullptr) {
1088             ret = HC_ERROR;
1089         }
1090     } while (0);
1091     DestroyDeviceAuthService();
1092     return ret;
1093 }
1094 
DevAuthTestCase028(void)1095 static int32_t DevAuthTestCase028(void)
1096 {
1097     DeleteDatabase();
1098     int32_t ret = InitDeviceAuthService();
1099     if (ret != HC_SUCCESS) {
1100         return ret;
1101     }
1102     do {
1103         const DeviceGroupManager *gm = GetGmInstance();
1104         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1105         if (ret != HC_SUCCESS) {
1106             break;
1107         }
1108         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1109         if (ret != HC_SUCCESS) {
1110             break;
1111         }
1112         uint32_t returnNum = 0;
1113         char* returnRes = nullptr;
1114         ret = gm->getTrustedDevices(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, &returnRes, &returnNum);
1115         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1116             ret = HC_ERROR;
1117         }
1118     } while (0);
1119     DestroyDeviceAuthService();
1120     return ret;
1121 }
1122 
DevAuthTestCase029(void)1123 static int32_t DevAuthTestCase029(void)
1124 {
1125     DeleteDatabase();
1126     int32_t ret = InitDeviceAuthService();
1127     if (ret != HC_SUCCESS) {
1128         return ret;
1129     }
1130     do {
1131         const DeviceGroupManager *gm = GetGmInstance();
1132         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1133         if (ret != HC_SUCCESS) {
1134             break;
1135         }
1136         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1137         if (ret != HC_SUCCESS) {
1138             break;
1139         }
1140         if (!gm->isDeviceInGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, TEST_AUTH_ID)) {
1141             ret = HC_ERROR;
1142         }
1143     } while (0);
1144     DestroyDeviceAuthService();
1145     return ret;
1146 }
1147 
DevAuthTestCase030(void)1148 static int32_t DevAuthTestCase030(void)
1149 {
1150     DeleteDatabase();
1151     int32_t ret = InitDeviceAuthService();
1152     if (ret != HC_SUCCESS) {
1153         return ret;
1154     }
1155     do {
1156         const DeviceGroupManager *gm = GetGmInstance();
1157         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1158         if (ret != HC_SUCCESS) {
1159             break;
1160         }
1161         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1162         if (ret != HC_SUCCESS) {
1163             break;
1164         }
1165         g_asyncStatus = ASYNC_STATUS_WAITING;
1166         bool isClient = true;
1167         SetDeviceStatus(isClient);
1168         ret = gm->addMemberToGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, ADD_PARAMS);
1169         if (ret != HC_SUCCESS) {
1170             g_asyncStatus = ASYNC_STATUS_WAITING;
1171             return ret;
1172         }
1173         while (g_asyncStatus == ASYNC_STATUS_WAITING) {
1174             usleep(TEST_DEV_AUTH_SLEEP_TIME);
1175         }
1176         (void)memset_s(g_transmitData, TEST_TRANSMIT_DATA_LEN, 0, TEST_TRANSMIT_DATA_LEN);
1177         g_transmitDataLen = 0;
1178         g_asyncStatus = ASYNC_STATUS_WAITING;
1179         gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1180     } while (0);
1181     DestroyDeviceAuthService();
1182     return HC_SUCCESS;
1183 }
1184 
DevAuthTestCase031(void)1185 static int32_t DevAuthTestCase031(void)
1186 {
1187     DeleteDatabase();
1188     int32_t ret = InitDeviceAuthService();
1189     if (ret != HC_SUCCESS) {
1190         return ret;
1191     }
1192     do {
1193         const DeviceGroupManager *gm = GetGmInstance();
1194         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1195         if (ret != HC_SUCCESS) {
1196             break;
1197         }
1198         gm->cancelRequest(TEST_REQ_ID, TEST_APP_ID);
1199     } while (0);
1200     DestroyDeviceAuthService();
1201     return HC_SUCCESS;
1202 }
1203 
DevAuthTestCase032(void)1204 static int32_t DevAuthTestCase032(void)
1205 {
1206     DeleteDatabase();
1207     int32_t ret = InitDeviceAuthService();
1208     if (ret != HC_SUCCESS) {
1209         return ret;
1210     }
1211     do {
1212         const DeviceGroupManager *gm = GetGmInstance();
1213         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1214         if (ret != HC_SUCCESS) {
1215             break;
1216         }
1217         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1218         if (ret != HC_SUCCESS) {
1219             break;
1220         }
1221         ret = AddDemoMember();
1222         if (ret != HC_SUCCESS) {
1223             break;
1224         }
1225         uint32_t returnNum = 0;
1226         char *returnRes = nullptr;
1227         ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, QUERY_PK_PARAMS, &returnRes, &returnNum);
1228         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1229             ret = HC_ERROR;
1230         }
1231     } while (0);
1232     DestroyDeviceAuthService();
1233     return ret;
1234 }
1235 
DevAuthTestCase033(void)1236 static int32_t DevAuthTestCase033(void)
1237 {
1238     DeleteDatabase();
1239     int32_t ret = InitDeviceAuthService();
1240     if (ret != HC_SUCCESS) {
1241         return ret;
1242     }
1243     do {
1244         const DeviceGroupManager *gm = GetGmInstance();
1245         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1246         if (ret != HC_SUCCESS) {
1247             break;
1248         }
1249         ret = CreateDemoGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, CREATE_PARAMS);
1250         if (ret != HC_SUCCESS) {
1251             break;
1252         }
1253         ret = AddDemoMember();
1254         if (ret != HC_SUCCESS) {
1255             break;
1256         }
1257         uint32_t returnNum = 0;
1258         char *returnRes = nullptr;
1259         ret = gm->getPkInfoList(DEFAULT_OS_ACCOUNT, TEST_APP_ID, QUERY_PK_PARAMS2, &returnRes, &returnNum);
1260         if (ret != HC_SUCCESS || returnNum == 0 || returnRes == nullptr) {
1261             ret = HC_ERROR;
1262         }
1263     } while (0);
1264     DestroyDeviceAuthService();
1265     return ret;
1266 }
1267 
DevAuthTestCase034(void)1268 static int32_t DevAuthTestCase034(void)
1269 {
1270     DeleteDatabase();
1271     SetDeviceStatus(true);
1272     int32_t ret = InitDeviceAuthService();
1273     if (ret != HC_SUCCESS) {
1274         return ret;
1275     }
1276     DestroyDeviceAuthService();
1277     SetDeviceStatus(false);
1278     ret = InitDeviceAuthService();
1279     if (ret != HC_SUCCESS) {
1280         return ret;
1281     }
1282     DestroyDeviceAuthService();
1283     SetDeviceStatus(true);
1284     ret = InitDeviceAuthService();
1285     if (ret != HC_SUCCESS) {
1286         return ret;
1287     }
1288     do {
1289         const DeviceGroupManager *gm = GetGmInstance();
1290         ret = gm->regCallback(TEST_APP_ID, &g_gmCallback);
1291         if (ret != HC_SUCCESS) {
1292             break;
1293         }
1294         SetDeviceStatus(true);
1295         ret = CreateDemoSymIdenticalAccountGroup(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
1296         if (ret != HC_SUCCESS) {
1297             break;
1298         }
1299         SetDeviceStatus(false);
1300         ret = CreateDemoSymIdenticalAccountGroup(TEST_AUTH_OS_ACCOUNT_ID, TEST_REQ_ID, TEST_APP_ID, TEST_USER_ID);
1301         if (ret != HC_SUCCESS) {
1302             break;
1303         }
1304         ret = AuthDemoMember();
1305     } while (0);
1306     DestroyDeviceAuthService();
1307     return ret;
1308 }
1309 
DevAuthTestCase051(void)1310 static int32_t DevAuthTestCase051(void)
1311 {
1312     SetPakeV1Supported(false);
1313     SetSessionV2Supported(false);
1314     int32_t ret = DevAuthTestCase007();
1315     SetPakeV1Supported(true);
1316     SetSessionV2Supported(true);
1317     return ret;
1318 }
1319 
DevAuthTestCase052(void)1320 static int32_t DevAuthTestCase052(void)
1321 {
1322     SetIsoSupported(false);
1323     SetPakeV1Supported(false);
1324     SetSessionV2Supported(false);
1325     int32_t ret = DevAuthTestCase007();
1326     SetIsoSupported(true);
1327     SetPakeV1Supported(true);
1328     SetSessionV2Supported(true);
1329     return ret;
1330 }
1331 
DevAuthTestCase053(void)1332 static int32_t DevAuthTestCase053(void)
1333 {
1334     SetIsoSupported(false);
1335     SetPakeV1Supported(false);
1336     int32_t ret = DevAuthTestCase007();
1337     SetIsoSupported(true);
1338     SetPakeV1Supported(true);
1339     return ret;
1340 }
1341 
DevAuthTestCase054(void)1342 static int32_t DevAuthTestCase054(void)
1343 {
1344     DeleteDatabase();
1345     int32_t ret = InitDeviceAuthService();
1346     if (ret != HC_SUCCESS) {
1347         return ret;
1348     }
1349     do {
1350         (void)ProcessTransmitCallback(TEST_REQ_ID, nullptr, TEST_DATA_LEN, nullptr);
1351         (void)ProcessSessionKeyCallback(TEST_REQ_ID, nullptr, TEST_DATA_LEN, nullptr);
1352         (void)ProcessFinishCallback(TEST_REQ_ID, 0, nullptr, nullptr);
1353         (void)ProcessErrorCallback(TEST_REQ_ID, 0, 0, nullptr, nullptr);
1354         (void)ProcessRequestCallback(TEST_REQ_ID, 0, nullptr, nullptr);
1355         (void)GetGMCallbackByAppId(nullptr);
1356         (void)RegGroupManagerCallback(nullptr, nullptr);
1357         (void)UnRegGroupManagerCallback(nullptr);
1358     } while (0);
1359     DestroyDeviceAuthService();
1360     return HC_SUCCESS;
1361 }
1362 
FuzzDoDevAuthFuncFuzz(const uint8_t * data,size_t size)1363 bool FuzzDoDevAuthFuncFuzz(const uint8_t* data, size_t size)
1364 {
1365     (void)data;
1366     (void)size;
1367     (void)DevAuthTestCase004();
1368     (void)DevAuthTestCase005();
1369     (void)DevAuthTestCase006();
1370     (void)DevAuthTestCase007();
1371     (void)DevAuthTestCase008();
1372     (void)DevAuthTestCase009();
1373     (void)DevAuthTestCase010();
1374     (void)DevAuthTestCase011();
1375     (void)DevAuthTestCase012();
1376     (void)DevAuthTestCase013();
1377     (void)DevAuthTestCase014();
1378     (void)DevAuthTestCase015();
1379     (void)DevAuthTestCase016();
1380     (void)DevAuthTestCase018();
1381     (void)DevAuthTestCase019();
1382     (void)DevAuthTestCase020();
1383     (void)DevAuthTestCase021();
1384     (void)DevAuthTestCase022();
1385     (void)DevAuthTestCase023();
1386     (void)DevAuthTestCase024();
1387     (void)DevAuthTestCase025();
1388     (void)DevAuthTestCase026();
1389     (void)DevAuthTestCase027();
1390     (void)DevAuthTestCase028();
1391     (void)DevAuthTestCase029();
1392     (void)DevAuthTestCase030();
1393     (void)DevAuthTestCase031();
1394     (void)DevAuthTestCase032();
1395     (void)DevAuthTestCase033();
1396     (void)DevAuthTestCase034();
1397     (void)DevAuthTestCase051();
1398     (void)DevAuthTestCase052();
1399     (void)DevAuthTestCase053();
1400     (void)DevAuthTestCase054();
1401     return true;
1402 }
1403 }
1404 
1405 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1406 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1407 {
1408     /* Run your code on data */
1409     OHOS::FuzzDoDevAuthFuncFuzz(data, size);
1410     return 0;
1411 }
1412 
1413