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