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