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
36namespace 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
68static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
69static const int TEST_DEV_AUTH_BUFFER_SIZE = 128;
70static const char *CREATE_PARAMS = "{\"groupName\":\"TestGroup\",\"deviceId\":\"TestAuthId\",\"groupType\":256,\"group"
71    "Visibility\":-1,\"userType\":0,\"expireTime\":-1}";
72static const char *CREATE_PARAMS2 = "{\"groupType\":1282,\"userId\":\"4269DC28B639681698809A67EDAD08E39F20790"
73    "0038F91FEF95DD042FE2874E4\",\"peerUserId\":\"6B7B805962B8EB8275D73128BFDAA7ECD755A2EC304E36543941874A277FA75F\"}";
74static const char *DISBAND_PARAMS =
75    "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\"}";
76static const char *DISBAND_PARAMS2 =
77    "{\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
78static const char *DISBAND_PARAMS3 =
79    "{\"groupId\":\"FF52352E8082CE2B34DEF7A55F40BA694F64D5200ADA86686B862772F3517A84\"}";
80static const char *ADD_PARAMS =
81    "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\","
82    "\"groupType\":256,\"pinCode\":\"123456\"}";
83static const char *AUTH_PARAMS = "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
84    "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true}";
85static 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\"}}]}";
95static const char *DEL_MULTI_PARAMS =
96    "{\"groupType\":1,\"groupId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\","
97    "\"deviceList\":[{\"deviceId\":\"TestAuthId2\"},{\"deviceId\":\"TestAuthId3\"}]}";
98static const char *DELETE_PARAMS =
99    "{\"groupId\":\"E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21\",\"deleteId\":\"TestAuthId2\"}";
100static const char *GET_REGISTER_INFO_PARAMS =
101    "{\"version\":\"1.0.0\",\"deviceId\":\"TestAuthId\","
102    "\"userId\":\"4269DC28B639681698809A67EDAD08E39F207900038F91FEF95DD042FE2874E4\"}";
103static const char *QUERY_PARAMS = "{\"groupOwner\":\"TestAppId\"}";
104static const char *QUERY_PK_PARAMS = "{\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD"
105    "2E6492C\",\"isSelfPk\":true}";
106static const char *QUERY_PK_PARAMS2 = "{\"udid\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD"
107    "2E6492C\",\"isSelfPk\":false}";
108
109enum AsyncStatus {
110    ASYNC_STATUS_WAITING = 0,
111    ASYNC_STATUS_TRANSMIT = 1,
112    ASYNC_STATUS_FINISH = 2,
113    ASYNC_STATUS_ERROR = 3
114};
115
116static AsyncStatus volatile g_asyncStatus;
117static uint8_t g_transmitData[2048] = { 0 };
118static uint32_t g_transmitDataLen = 0;
119
120static 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
130static 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
138static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
139{
140    g_asyncStatus = ASYNC_STATUS_FINISH;
141}
142
143static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
144{
145    g_asyncStatus = ASYNC_STATUS_ERROR;
146}
147
148static 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
160static 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
172static DeviceAuthCallback g_gmCallback = {
173    .onTransmit = OnTransmit,
174    .onSessionKeyReturned = OnSessionKeyReturned,
175    .onFinish = OnFinish,
176    .onError = OnError,
177    .onRequest = OnBindRequest
178};
179
180static DeviceAuthCallback g_gaCallback = {
181    .onTransmit = OnTransmit,
182    .onSessionKeyReturned = OnSessionKeyReturned,
183    .onFinish = OnFinish,
184    .onError = OnError,
185    .onRequest = OnAuthRequest
186};
187
188static void OnGroupCreated(const char *groupInfo) {}
189
190static void OnGroupDeleted(const char *groupInfo) {}
191
192static void OnDeviceBound(const char *peerUdid, const char* groupInfo) {}
193
194static void OnDeviceUnBound(const char *peerUdid, const char* groupInfo) {}
195
196static void OnDeviceNotTrusted(const char *peerUdid) {}
197
198static void OnLastGroupDeleted(const char *peerUdid, int groupType) {}
199
200static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum) {}
201
202static 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
212static 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
225static 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
233static 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
247static 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
297static 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
316static 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
354static 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
387static 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
405static 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
452static 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
498static 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
516static 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
535static 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
554static 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
577static 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
604static 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
631static 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
654static 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
675static 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
694static 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
717static 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
759static 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
786static 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
813static 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
836static 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
863static 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
878static 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
913static 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
932static 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
955static 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
982static 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
1010static 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
1038static 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
1066static 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
1093static 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
1121static 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
1146static 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
1183static 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
1202static 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
1234static 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
1266static 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
1308static 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
1318static 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
1330static 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
1340bool 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 */
1382extern "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