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