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
34 using namespace std;
35 using namespace testing::ext;
36
37 namespace {
38 #define TEST_REQ_ID 123
39 #define TEST_REQ_ID2 321
40 #define TEST_APP_ID "TestAppId"
41 #define TEST_UDID "TestUdid"
42 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
43 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
44 #define TEST_PIN_CODE "123456"
45 #define TEST_DEV_AUTH_SLEEP_TIME 50000
46 static const int32_t TEST_AUTH_OS_ACCOUNT_ID = 100;
47
48 static const char *AUTH_WITH_PIN_PARAMS = "{\"osAccountId\":100,\"acquireType\":0,\"pinCode\":\"123456\"}";
49
50 static const char *AUTH_DIRECT_PARAMS =
51 "{\"osAccountId\":100,\"acquireType\":0,\"serviceType\":\"service.type.import\",\"peerConnDeviceId\":"
52 "\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
53 "749558BD2E6492C\"}";
54
55 static const char *DEVICE_LEVEL_AUTH_PARAMS =
56 "{\"peerConnDeviceId\":\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
57 "749558BD2E6492C\",\"servicePkgName\":\"TestAppId\",\"isClient\":true, \"isDeviceLevel\":true}";
58
59 enum AsyncStatus {
60 ASYNC_STATUS_WAITING = 0,
61 ASYNC_STATUS_TRANSMIT = 1,
62 ASYNC_STATUS_FINISH = 2,
63 ASYNC_STATUS_ERROR = 3
64 };
65
66 static AsyncStatus volatile g_asyncStatus;
67 static uint32_t g_transmitDataMaxLen = 2048;
68 static uint8_t g_transmitData[2048] = { 0 };
69 static uint32_t g_transmitDataLen = 0;
70
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)71 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
72 {
73 if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
74 return false;
75 }
76 g_transmitDataLen = dataLen;
77 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
78 return true;
79 }
80
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)81 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
82 {
83 (void)requestId;
84 (void)sessionKey;
85 (void)sessionKeyLen;
86 return;
87 }
88
OnFinish(int64_t requestId,int operationCode,const char * authReturn)89 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
90 {
91 g_asyncStatus = ASYNC_STATUS_FINISH;
92 }
93
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)94 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
95 {
96 g_asyncStatus = ASYNC_STATUS_ERROR;
97 }
98
OnAuthRequest(int64_t requestId,int operationCode,const char * reqParam)99 static char *OnAuthRequest(int64_t requestId, int operationCode, const char *reqParam)
100 {
101 CJson *json = CreateJson();
102 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
103 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
104 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
105 AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_ID);
106 char *returnDataStr = PackJsonToString(json);
107 FreeJson(json);
108 return returnDataStr;
109 }
110
OnAuthRequestDirectTmp(int64_t requestId,int operationCode,const char * reqParam)111 static char *OnAuthRequestDirectTmp(int64_t requestId, int operationCode, const char *reqParam)
112 {
113 CJson *json = CreateJson();
114 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
115 AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
116 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
117 char *returnDataStr = PackJsonToString(json);
118 FreeJson(json);
119 return returnDataStr;
120 }
121
OnAuthRequestDirect(int64_t requestId,int operationCode,const char * reqParam)122 static char *OnAuthRequestDirect(int64_t requestId, int operationCode, const char *reqParam)
123 {
124 CJson *json = CreateJson();
125 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
126 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
127 AddStringToJson(json, FIELD_SERVICE_TYPE, SERVICE_TYPE_IMPORT);
128 char *returnDataStr = PackJsonToString(json);
129 FreeJson(json);
130 return returnDataStr;
131 }
132
133 static DeviceAuthCallback g_gaCallback = { .onTransmit = OnTransmit,
134 .onSessionKeyReturned = OnSessionKeyReturned,
135 .onFinish = OnFinish,
136 .onError = OnError,
137 .onRequest = OnAuthRequest };
138
139 static DeviceAuthCallback g_daTmpCallback = { .onTransmit = OnTransmit,
140 .onSessionKeyReturned = OnSessionKeyReturned,
141 .onFinish = OnFinish,
142 .onError = OnError,
143 .onRequest = OnAuthRequestDirectTmp };
144
145 static DeviceAuthCallback g_daLTCallback = { .onTransmit = OnTransmit,
146 .onSessionKeyReturned = OnSessionKeyReturned,
147 .onFinish = OnFinish,
148 .onError = OnError,
149 .onRequest = OnAuthRequestDirect };
150
AuthDeviceDirectWithPinDemo(const char * startAuthParams,const DeviceAuthCallback * callback)151 static void AuthDeviceDirectWithPinDemo(const char *startAuthParams, const DeviceAuthCallback *callback)
152 {
153 g_asyncStatus = ASYNC_STATUS_WAITING;
154 bool isClient = true;
155 SetDeviceStatus(isClient);
156
157 int32_t ret = StartAuthDevice(TEST_REQ_ID, startAuthParams, callback);
158 if (ret != HC_SUCCESS) {
159 g_asyncStatus = ASYNC_STATUS_ERROR;
160 return;
161 }
162 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
163 usleep(TEST_DEV_AUTH_SLEEP_TIME);
164 }
165 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
166 isClient = !isClient;
167 SetDeviceStatus(isClient);
168 g_asyncStatus = ASYNC_STATUS_WAITING;
169 CJson *json = CreateJson();
170 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
171 AddStringToJson(json, "data", (const char *)g_transmitData);
172 char *autParams = PackJsonToString(json);
173 FreeJson(json);
174 if (isClient) {
175 ret = ProcessAuthDevice(TEST_REQ_ID, autParams, callback);
176 } else {
177 ret = ProcessAuthDevice(TEST_REQ_ID2, autParams, callback);
178 }
179 FreeJsonString(autParams);
180 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
181 g_transmitDataLen = 0;
182 if (ret != HC_SUCCESS) {
183 g_asyncStatus = ASYNC_STATUS_ERROR;
184 return;
185 }
186 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
187 usleep(TEST_DEV_AUTH_SLEEP_TIME);
188 }
189 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
190 break;
191 }
192 if (g_transmitDataLen > 0) {
193 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
194 }
195 }
196 SetDeviceStatus(true);
197 }
198
AuthDeviceDirectDemo(const char * startAuthParams,const DeviceAuthCallback * callback)199 static void AuthDeviceDirectDemo(const char *startAuthParams, const DeviceAuthCallback *callback)
200 {
201 g_asyncStatus = ASYNC_STATUS_WAITING;
202 bool isClient = true;
203 SetDeviceStatus(isClient);
204
205 int32_t ret = StartAuthDevice(TEST_REQ_ID, startAuthParams, callback);
206 if (ret != HC_SUCCESS) {
207 g_asyncStatus = ASYNC_STATUS_ERROR;
208 return;
209 }
210 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
211 usleep(TEST_DEV_AUTH_SLEEP_TIME);
212 }
213 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
214 isClient = !isClient;
215 SetDeviceStatus(isClient);
216 g_asyncStatus = ASYNC_STATUS_WAITING;
217 CJson *json = CreateJson();
218 AddIntToJson(json, FIELD_OS_ACCOUNT_ID, TEST_AUTH_OS_ACCOUNT_ID);
219 AddStringToJson(json, "data", (const char *)g_transmitData);
220 char *autParams = PackJsonToString(json);
221 FreeJson(json);
222 if (isClient) {
223 ret = ProcessAuthDevice(TEST_REQ_ID, autParams, callback);
224 } else {
225 ret = ProcessAuthDevice(TEST_REQ_ID2, autParams, callback);
226 }
227 FreeJsonString(autParams);
228 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
229 g_transmitDataLen = 0;
230 if (ret != HC_SUCCESS) {
231 g_asyncStatus = ASYNC_STATUS_ERROR;
232 return;
233 }
234 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
235 usleep(TEST_DEV_AUTH_SLEEP_TIME);
236 }
237 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
238 break;
239 }
240 if (g_transmitDataLen > 0) {
241 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
242 }
243 }
244 SetDeviceStatus(true);
245 }
246
DeviceLevelAuthDemo(void)247 static void DeviceLevelAuthDemo(void)
248 {
249 g_asyncStatus = ASYNC_STATUS_WAITING;
250 bool isClient = true;
251 SetDeviceStatus(isClient);
252 const GroupAuthManager *ga = GetGaInstance();
253 ASSERT_NE(ga, nullptr);
254 int32_t ret = ga->authDevice(DEFAULT_OS_ACCOUNT, TEST_REQ_ID, DEVICE_LEVEL_AUTH_PARAMS, &g_gaCallback);
255 if (ret != HC_SUCCESS) {
256 g_asyncStatus = ASYNC_STATUS_ERROR;
257 return;
258 }
259 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
260 usleep(TEST_DEV_AUTH_SLEEP_TIME);
261 }
262 while (g_asyncStatus == ASYNC_STATUS_TRANSMIT) {
263 isClient = !isClient;
264 SetDeviceStatus(isClient);
265 g_asyncStatus = ASYNC_STATUS_WAITING;
266 if (isClient) {
267 ret = ga->processData(TEST_REQ_ID, g_transmitData, g_transmitDataLen, &g_gaCallback);
268 } else {
269 ret = ga->processData(TEST_REQ_ID2, g_transmitData, g_transmitDataLen, &g_gaCallback);
270 }
271 (void)memset_s(g_transmitData, g_transmitDataMaxLen, 0, g_transmitDataMaxLen);
272 g_transmitDataLen = 0;
273 if (ret != HC_SUCCESS) {
274 g_asyncStatus = ASYNC_STATUS_ERROR;
275 return;
276 }
277 while (g_asyncStatus == ASYNC_STATUS_WAITING) {
278 usleep(TEST_DEV_AUTH_SLEEP_TIME);
279 }
280 if (g_asyncStatus == ASYNC_STATUS_ERROR) {
281 break;
282 }
283 if (g_transmitDataLen > 0) {
284 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
285 }
286 }
287 SetDeviceStatus(true);
288 }
289
CreateCredentialParamsJson(int32_t osAccountId,const char * deviceId,int32_t flag,const char * serviceType,CJson * out)290 static void CreateCredentialParamsJson(int32_t osAccountId, const char *deviceId, int32_t flag,
291 const char *serviceType, CJson *out)
292 {
293 AddIntToJson(out, FIELD_OS_ACCOUNT_ID, osAccountId);
294 AddStringToJson(out, FIELD_DEVICE_ID, deviceId);
295 AddStringToJson(out, FIELD_SERVICE_TYPE, serviceType);
296 AddIntToJson(out, FIELD_ACQURIED_TYPE, P2P_BIND);
297
298 if (flag >= 0) {
299 AddIntToJson(out, FIELD_CRED_OP_FLAG, flag);
300 }
301 return;
302 }
303
ProcessCredentiaCreateDemo(const int32_t osAccountId,const bool isClient,const char * udid)304 static int32_t ProcessCredentiaCreateDemo(const int32_t osAccountId, const bool isClient, const char *udid)
305 {
306 int32_t flag = RETURN_FLAG_PUBLIC_KEY;
307 CJson *json = CreateJson();
308 if (json == NULL) {
309 return HC_ERR_ALLOC_MEMORY;
310 }
311 CreateCredentialParamsJson(osAccountId, udid, flag, DEFAULT_SERVICE_TYPE, json);
312 char *requestParams = PackJsonToString(json);
313 FreeJson(json);
314 char *returnData = nullptr;
315 SetDeviceStatus(isClient);
316
317 int32_t res = ProcessCredential(CRED_OP_CREATE, requestParams, &returnData);
318 FreeJsonString(requestParams);
319 if (returnData) {
320 printf("returnData: %s\n", returnData);
321 CJson *in = CreateJsonFromString(returnData);
322 if (in == nullptr) {
323 printf("CreateJsonFromString returnData failed !\n");
324 } else {
325 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
326 printf("GetIntFromJson result failed !\n");
327 FreeJson(in);
328 return HC_ERR_INVALID_PARAMS;
329 }
330 printf("get result from returnData: %d\n", res);
331 SetDeviceStatus(true);
332 return res;
333 }
334 }
335
336 printf("returnData is null !\n");
337
338 SetDeviceStatus(true);
339 return res;
340 }
341
ProcessCredentialQueryDemo(const int32_t osAccountId,const bool isClient,const char * udid,char ** publicKey)342 static int32_t ProcessCredentialQueryDemo(
343 const int32_t osAccountId, const bool isClient, const char *udid, char **publicKey)
344 {
345 int32_t flag = RETURN_FLAG_PUBLIC_KEY;
346
347 char *returnData = nullptr;
348 SetDeviceStatus(isClient);
349 CJson *json = CreateJson();
350 if (json == NULL) {
351 return HC_ERR_ALLOC_MEMORY;
352 }
353 CreateCredentialParamsJson(osAccountId, udid, flag, DEFAULT_SERVICE_TYPE, json);
354 char *requestParams = PackJsonToString(json);
355 FreeJson(json);
356
357 int32_t res = ProcessCredential(CRED_OP_QUERY, requestParams, &returnData);
358 FreeJsonString(requestParams);
359 if (returnData) {
360 printf("returnData: %s\n", returnData);
361 CJson *in = CreateJsonFromString(returnData);
362 if (in == nullptr) {
363 printf("CreateJsonFromString returnData failed !\n");
364 } else {
365 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
366 printf("GetIntFromJson result failed !\n");
367 FreeJson(in);
368 return HC_ERR_INVALID_PARAMS;
369 }
370 printf("get result from returnData: %d\n", res);
371 *publicKey = (char *)GetStringFromJson(in, FIELD_PUBLIC_KEY);
372 SetDeviceStatus(true);
373 return res;
374 }
375 }
376
377 printf("returnData is null !\n");
378
379 SetDeviceStatus(true);
380 return res;
381 }
382
ProcessCredentialDemoImpPubKey(const int32_t osAccountId,const bool isClient,const char * udid,const char * publicKey)383 static int32_t ProcessCredentialDemoImpPubKey(
384 const int32_t osAccountId, const bool isClient, const char *udid, const char *publicKey)
385 {
386 CJson *json = CreateJson();
387 if (json == NULL) {
388 return HC_ERR_ALLOC_MEMORY;
389 }
390 CreateCredentialParamsJson(osAccountId, udid, RETURN_FLAG_INVALID, SERVICE_TYPE_IMPORT, json);
391 AddStringToJson(json, FIELD_PUBLIC_KEY, publicKey);
392 char *requestParams = PackJsonToString(json);
393 FreeJson(json);
394 char *returnData = nullptr;
395 SetDeviceStatus(isClient);
396
397 int32_t res = ProcessCredential(CRED_OP_IMPORT, requestParams, &returnData);
398 FreeJsonString(requestParams);
399 if (returnData) {
400 CJson *in = CreateJsonFromString(returnData);
401 if (in == nullptr) {
402 printf("CreateJsonFromString returnData failed !\n");
403 } else {
404 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
405 printf("GetIntFromJson result failed !\n");
406 FreeJson(in);
407 return HC_ERR_INVALID_PARAMS;
408 }
409 printf("get result from returnData: %d\n", res);
410 SetDeviceStatus(true);
411 return res;
412 }
413 }
414
415 printf("returnData is null !\n");
416
417 SetDeviceStatus(true);
418 return res;
419 }
420
CreateServerKeyPair()421 static int32_t CreateServerKeyPair()
422 {
423 SetDeviceStatus(false);
424 CJson *json = CreateJson();
425 if (json == NULL) {
426 return HC_ERR_ALLOC_MEMORY;
427 }
428 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID_SERVER,
429 RETURN_FLAG_PUBLIC_KEY, DEFAULT_SERVICE_TYPE, json);
430 char *requestParams = PackJsonToString(json);
431 FreeJson(json);
432 char *returnData = nullptr;
433
434 printf("ProcessCredentialDemo: operationCode=%d\n", CRED_OP_CREATE);
435 int32_t res = ProcessCredential(CRED_OP_CREATE, requestParams, &returnData);
436 FreeJsonString(requestParams);
437 if (returnData) {
438 printf("returnData: %s\n", returnData);
439 CJson *in = CreateJsonFromString(returnData);
440 if (in == nullptr) {
441 printf("CreateJsonFromString returnData failed !\n");
442 } else {
443 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
444 printf("GetIntFromJson result failed !\n");
445 FreeJson(in);
446 return HC_ERR_INVALID_PARAMS;
447 }
448 printf("get result from returnData: %d\n", res);
449 return res;
450 }
451 }
452
453 printf("returnData is null !\n");
454
455 SetDeviceStatus(true);
456 return res;
457 }
458
DeleteServerKeyPair()459 static int32_t DeleteServerKeyPair()
460 {
461 SetDeviceStatus(false);
462 CJson *json = CreateJson();
463 if (json == NULL) {
464 return HC_ERR_ALLOC_MEMORY;
465 }
466 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID_SERVER,
467 RETURN_FLAG_PUBLIC_KEY, DEFAULT_SERVICE_TYPE, json);
468 char *requestParams = PackJsonToString(json);
469 FreeJson(json);
470 char *returnData = nullptr;
471
472 printf("ProcessCredentialDemo: operationCode=%d\n", CRED_OP_DELETE);
473 int32_t res = ProcessCredential(CRED_OP_DELETE, requestParams, &returnData);
474 FreeJsonString(requestParams);
475 if (returnData) {
476 printf("returnData: %s\n", returnData);
477 CJson *in = CreateJsonFromString(returnData);
478 if (in == nullptr) {
479 printf("CreateJsonFromString returnData failed !\n");
480 } else {
481 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
482 printf("GetIntFromJson result failed !\n");
483 FreeJson(in);
484 return HC_ERR_INVALID_PARAMS;
485 }
486 printf("get result from returnData: %d\n", res);
487 return res;
488 }
489 }
490
491 printf("returnData is null !\n");
492
493 SetDeviceStatus(true);
494 return res;
495 }
496
DeleteAllCredentails()497 static int32_t DeleteAllCredentails()
498 {
499 SetDeviceStatus(false);
500 CJson *json = CreateJson();
501 if (json == NULL) {
502 return HC_ERR_ALLOC_MEMORY;
503 }
504 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID_SERVER,
505 RETURN_FLAG_DEFAULT, DEFAULT_SERVICE_TYPE, json);
506 char *requestParams = PackJsonToString(json);
507 FreeJson(json);
508 char *returnData = nullptr;
509 ProcessCredential(CRED_OP_DELETE, requestParams, &returnData);
510 FreeJsonString(requestParams);
511
512 SetDeviceStatus(true);
513 json = CreateJson();
514 if (json == NULL) {
515 return HC_ERR_ALLOC_MEMORY;
516 }
517 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID_CLIENT,
518 RETURN_FLAG_DEFAULT, DEFAULT_SERVICE_TYPE, json);
519 requestParams = PackJsonToString(json);
520 FreeJson(json);
521 returnData = nullptr;
522 ProcessCredential(CRED_OP_DELETE, requestParams, &returnData);
523 FreeJsonString(requestParams);
524
525 return HC_SUCCESS;
526 }
527
ProcessCredentialDemo(int operationCode,const char * serviceType)528 static int32_t ProcessCredentialDemo(int operationCode, const char *serviceType)
529 {
530 int32_t flag = RETURN_FLAG_INVALID;
531 if (operationCode == CRED_OP_CREATE || operationCode == CRED_OP_QUERY) {
532 flag = RETURN_FLAG_PUBLIC_KEY;
533 }
534 CJson *json = CreateJson();
535 if (json == NULL) {
536 return HC_ERR_ALLOC_MEMORY;
537 }
538 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID, flag, serviceType, json);
539 char *requestParams = PackJsonToString(json);
540 FreeJson(json);
541 char *returnData = nullptr;
542 bool isClient = true;
543 SetDeviceStatus(isClient);
544
545 printf("ProcessCredentialDemo: operationCode=%d\n", operationCode);
546 int32_t res = ProcessCredential(operationCode, requestParams, &returnData);
547 FreeJsonString(requestParams);
548 if (returnData) {
549 printf("returnData: %s\n", returnData);
550 CJson *in = CreateJsonFromString(returnData);
551 if (in == nullptr) {
552 printf("CreateJsonFromString returnData failed !\n");
553 } else {
554 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
555 printf("GetIntFromJson result failed !\n");
556 FreeJson(in);
557 return HC_ERR_INVALID_PARAMS;
558 }
559 printf("get result from returnData: %d\n", res);
560 SetDeviceStatus(true);
561 return res;
562 }
563 }
564
565 printf("returnData is null !\n");
566
567 SetDeviceStatus(true);
568 return res;
569 }
570
ProcessCredentialDemoImport(const char * importServiceType)571 static int32_t ProcessCredentialDemoImport(const char *importServiceType)
572 {
573 CJson *json = CreateJson();
574 if (json == NULL) {
575 return HC_ERR_ALLOC_MEMORY;
576 }
577 CreateCredentialParamsJson(TEST_AUTH_OS_ACCOUNT_ID, TEST_UDID, RETURN_FLAG_INVALID, importServiceType, json);
578 AddStringToJson(json, FIELD_PUBLIC_KEY,
579 "CA32A9DFACB944B1F6292C9AE10783F6376A987A9CE30C13300BC866917DFF2E");
580 char *requestParams = PackJsonToString(json);
581 FreeJson(json);
582 char *returnData = nullptr;
583 bool isClient = false;
584 SetDeviceStatus(isClient);
585
586 printf("ProcessCredentialDemoImport\n");
587 int32_t res = ProcessCredential(CRED_OP_IMPORT, requestParams, &returnData);
588 FreeJsonString(requestParams);
589 if (returnData) {
590 CJson *in = CreateJsonFromString(returnData);
591 if (in == nullptr) {
592 printf("CreateJsonFromString returnData failed !\n");
593 } else {
594 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
595 printf("GetIntFromJson result failed !\n");
596 FreeJson(in);
597 return HC_ERR_INVALID_PARAMS;
598 }
599 printf("get result from returnData: %d\n", res);
600 SetDeviceStatus(true);
601 return res;
602 }
603 }
604
605 printf("returnData is null !\n");
606
607 SetDeviceStatus(true);
608 return res;
609 }
610
611 class DaAuthDeviceTest : public testing::Test {
612 public:
613 static void SetUpTestCase();
614 static void TearDownTestCase();
615 void SetUp();
616 void TearDown();
617 };
618
SetUpTestCase()619 void DaAuthDeviceTest::SetUpTestCase() {}
620
TearDownTestCase()621 void DaAuthDeviceTest::TearDownTestCase() {}
622
SetUp()623 void DaAuthDeviceTest::SetUp()
624 {
625 int32_t ret = InitDeviceAuthService();
626 ASSERT_EQ(ret, HC_SUCCESS);
627 }
628
TearDown()629 void DaAuthDeviceTest::TearDown()
630 {
631 DestroyDeviceAuthService();
632 }
633
634 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest001, TestSize.Level0)
635 {
636 SetIsoSupported(false);
637 SetPakeV1Supported(true);
638 SetDeviceStatus(true);
639 AuthDeviceDirectWithPinDemo(AUTH_WITH_PIN_PARAMS, &g_daTmpCallback);
640 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
641 }
642 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest002, TestSize.Level0)
643 {
644 SetIsoSupported(false);
645 SetPakeV1Supported(true);
646 SetDeviceStatus(true);
647 AuthDeviceDirectDemo(AUTH_DIRECT_PARAMS, &g_daLTCallback);
648 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
649 }
650
651 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest003, TestSize.Level0)
652 {
653 SetIsoSupported(false);
654 SetPakeV1Supported(true);
655 SetDeviceStatus(true);
656 int32_t res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
657 ASSERT_EQ(res, HC_SUCCESS);
658 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
659 ASSERT_NE(res, HC_SUCCESS);
660 res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
661 ASSERT_EQ(res, HC_SUCCESS);
662 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
663 ASSERT_EQ(res, HC_SUCCESS);
664 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
665 ASSERT_EQ(res, HC_SUCCESS);
666 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
667 ASSERT_NE(res, HC_SUCCESS);
668 }
669
670 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest004, TestSize.Level0)
671 {
672 SetIsoSupported(false);
673 SetPakeV1Supported(true);
674 SetDeviceStatus(true);
675
676 int32_t res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
677 ASSERT_EQ(res, HC_SUCCESS);
678 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
679 ASSERT_EQ(res, HC_SUCCESS);
680 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
681 ASSERT_EQ(res, HC_SUCCESS);
682 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
683 ASSERT_NE(res, HC_SUCCESS);
684 }
685
686 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest005, TestSize.Level0)
687 {
688 SetIsoSupported(false);
689 SetPakeV1Supported(true);
690 SetDeviceStatus(true);
691 int32_t res = CreateServerKeyPair();
692 ASSERT_EQ(res, HC_SUCCESS);
693 res = ProcessCredentialDemoImport(SERVICE_TYPE_IMPORT);
694 ASSERT_EQ(res, HC_SUCCESS);
695 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
696 ASSERT_EQ(res, HC_SUCCESS);
697 res = ProcessCredentialDemo(CRED_OP_DELETE, SERVICE_TYPE_IMPORT);
698 ASSERT_EQ(res, HC_SUCCESS);
699 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
700 ASSERT_NE(res, HC_SUCCESS);
701 res = DeleteServerKeyPair();
702 ASSERT_EQ(res, HC_SUCCESS);
703 }
704
705 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest006, TestSize.Level0)
706 {
707 SetIsoSupported(false);
708 SetPakeV1Supported(true);
709 SetDeviceStatus(true);
710 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
711 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER);
712 char *publicKey = nullptr;
713 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER, &publicKey);
714 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_SERVER, publicKey);
715 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT, &publicKey);
716 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_CLIENT, publicKey);
717 DeviceLevelAuthDemo();
718 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
719 }
720
721 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest007, TestSize.Level0)
722 {
723 SetIsoSupported(false);
724 SetPakeV1Supported(true);
725 SetDeviceStatus(true);
726
727 CJson *in = CreateJsonFromString("{\"testKey\":\"testValue\"}");
728 CertInfo *certInfo = (CertInfo *)HcMalloc(sizeof(CertInfo *), 0);
729 IdentityInfo *identityInfo = (IdentityInfo *)HcMalloc(sizeof(IdentityInfo *), 0);
730
731 int32_t res = GetCredInfoByPeerCert(in, certInfo, &identityInfo);
732
733 HcFree(identityInfo);
734 HcFree(certInfo);
735 FreeJson(in);
736
737 ASSERT_NE(res, HC_SUCCESS);
738 }
739
740 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest008, TestSize.Level0)
741 {
742 SetIsoSupported(false);
743 SetPakeV1Supported(true);
744 SetDeviceStatus(true);
745
746 CJson *in = CreateJsonFromString("{\"osAccountId\":\"100\"}");
747 CertInfo *certInfo = (CertInfo *)HcMalloc(sizeof(CertInfo *), 0);
748 uint8_t val[] = { 0, 0 };
749 Uint8Buff sharedSecret = { val, sizeof(val) };
750
751 int32_t res = GetSharedSecretByPeerCert(in, certInfo, ALG_EC_SPEKE, &sharedSecret);
752 HcFree(certInfo);
753 FreeJson(in);
754 ASSERT_NE(res, HC_SUCCESS);
755
756 res = GetSharedSecretByPeerCert(nullptr, nullptr, ALG_EC_SPEKE, &sharedSecret);
757 ASSERT_NE(res, HC_SUCCESS);
758 }
759
760 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest009, TestSize.Level0)
761 {
762 SetIsoSupported(false);
763 SetPakeV1Supported(true);
764 SetDeviceStatus(true);
765
766 CJson *in = CreateJsonFromString("{\"osAccountId\":\"100\"}");
767 uint8_t val[] = { 0, 0 };
768 Uint8Buff sharedSecret = { val, sizeof(val) };
769 Uint8Buff presharedUrl = { val, sizeof(val) };
770
771 int32_t res = GetSharedSecretByUrl(in, &presharedUrl, ALG_ISO, &sharedSecret);
772 FreeJson(in);
773 ASSERT_NE(res, HC_SUCCESS);
774
775 res = GetSharedSecretByUrl(nullptr, &presharedUrl, ALG_ISO, &sharedSecret);
776 ASSERT_NE(res, HC_SUCCESS);
777 }
778
779 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest010, TestSize.Level0)
780 {
781 SetIsoSupported(false);
782 SetPakeV1Supported(true);
783 SetDeviceStatus(true);
784
785 CJson *in = CreateJsonFromString("{\"pinCode\":\"123456\",\"seed\":"
786 "\"CA32A9DFACB944B1F6292C9AE10783F6376A987A9CE30C13300BC866917DFF2E\"}");
787 uint8_t val[] = { 0, 0 };
788 Uint8Buff sharedSecret = { val, sizeof(val) };
789 Uint8Buff presharedUrl = { val, sizeof(val) };
790
791 int32_t res = GetSharedSecretByUrl(in, &presharedUrl, ALG_ISO, &sharedSecret);
792 FreeJson(in);
793 ASSERT_EQ(res, HC_SUCCESS);
794
795 res = GetSharedSecretByUrl(nullptr, &presharedUrl, ALG_ISO, &sharedSecret);
796 ASSERT_NE(res, HC_SUCCESS);
797 }
798
799 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest011, TestSize.Level0)
800 {
801 SetIsoSupported(false);
802 SetPakeV1Supported(true);
803 SetDeviceStatus(true);
804
805 const AuthIdentityManager *authIdentityManager = GetAuthIdentityManager();
806 ASSERT_NE(authIdentityManager, nullptr);
807 }
808
809 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest012, TestSize.Level0)
810 {
811 SetIsoSupported(false);
812 SetPakeV1Supported(true);
813 SetDeviceStatus(true);
814
815 const AuthIdentity *authIdentity = GetAuthIdentityByType(AUTH_IDENTITY_TYPE_INVALID);
816 ASSERT_EQ(authIdentity, nullptr);
817 }
818
819 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest013, TestSize.Level0)
820 {
821 SetIsoSupported(false);
822 SetPakeV1Supported(true);
823 SetDeviceStatus(true);
824
825 CJson *in = CreateJsonFromString("{\"groupId\":\"123456\",\"seed\":"
826 "\"CA32A9DFACB944B1F6292C9AE10783F6376A987A9CE30C13300BC866917DFF2E\"}");
827 uint8_t val[] = { 0, 0 };
828 Uint8Buff sharedSecret = { val, sizeof(val) };
829 const char *credUrl = "{\"credentialType\":0,\"keyType\":1,\"trustType\":1,\"groupId\":\"123456\"}";
830 Uint8Buff presharedUrl = { (uint8_t *)credUrl, HcStrlen(credUrl) };
831
832 int32_t res = GetSharedSecretByUrl(in, &presharedUrl, ALG_ISO, &sharedSecret);
833 FreeJson(in);
834 ASSERT_NE(res, HC_SUCCESS);
835 }
836
837 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest014, TestSize.Level0)
838 {
839 SetIsoSupported(false);
840 SetPakeV1Supported(true);
841 SetDeviceStatus(true);
842
843 const CredentialOperator *credentialOperator = GetCredentialOperator();
844
845 int32_t res = credentialOperator->queryCredential(nullptr, nullptr);
846 ASSERT_NE(res, HC_SUCCESS);
847
848 res = credentialOperator->genarateCredential(nullptr, nullptr);
849 ASSERT_NE(res, HC_SUCCESS);
850
851 res = credentialOperator->importCredential(nullptr, nullptr);
852 ASSERT_NE(res, HC_SUCCESS);
853
854 res = credentialOperator->deleteCredential(nullptr, nullptr);
855 ASSERT_NE(res, HC_SUCCESS);
856 }
857
858 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest015, TestSize.Level0)
859 {
860 SetIsoSupported(false);
861 SetPakeV1Supported(true);
862 SetDeviceStatus(true);
863
864 const CredentialOperator *credentialOperator = GetCredentialOperator();
865
866 const char *reqJsonStr = "{\"deviceId\":\"123456\",\"osAccountId\":0,\"acquireType\":0}";
867 char *returnData = nullptr;
868 int32_t res = credentialOperator->queryCredential(reqJsonStr, &returnData);
869 ASSERT_NE(res, HC_SUCCESS);
870
871 res = credentialOperator->genarateCredential(reqJsonStr, &returnData);
872 ASSERT_EQ(res, HC_SUCCESS);
873
874 res = credentialOperator->importCredential(reqJsonStr, &returnData);
875 ASSERT_NE(res, HC_SUCCESS);
876
877 res = credentialOperator->deleteCredential(reqJsonStr, &returnData);
878 ASSERT_EQ(res, HC_SUCCESS);
879 }
880
881 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest016, TestSize.Level0)
882 {
883 SetIsoSupported(false);
884 SetPakeV1Supported(true);
885 SetDeviceStatus(true);
886
887 const CredentialOperator *credentialOperator = GetCredentialOperator();
888
889 const char *reqJsonStr = "{\"osAccountId\":0,\"acquireType\":0}";
890 char *returnData = nullptr;
891 int32_t res = credentialOperator->queryCredential(reqJsonStr, &returnData);
892 ASSERT_NE(res, HC_SUCCESS);
893
894 res = credentialOperator->genarateCredential(reqJsonStr, &returnData);
895 ASSERT_NE(res, HC_SUCCESS);
896
897 res = credentialOperator->importCredential(reqJsonStr, &returnData);
898 ASSERT_NE(res, HC_SUCCESS);
899
900 res = credentialOperator->deleteCredential(reqJsonStr, &returnData);
901 ASSERT_NE(res, HC_SUCCESS);
902 }
903
904 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest017, TestSize.Level0)
905 {
906 SetIsoSupported(false);
907 SetPakeV1Supported(true);
908 SetDeviceStatus(true);
909
910 const CredentialOperator *credentialOperator = GetCredentialOperator();
911
912 const char *reqJsonStr = "{\"deviceId\":\"123456\",\"acquireType\":0}";
913 char *returnData = nullptr;
914 int32_t res = credentialOperator->queryCredential(reqJsonStr, &returnData);
915 ASSERT_NE(res, HC_SUCCESS);
916
917 res = credentialOperator->genarateCredential(reqJsonStr, &returnData);
918 ASSERT_NE(res, HC_SUCCESS);
919
920 res = credentialOperator->importCredential(reqJsonStr, &returnData);
921 ASSERT_NE(res, HC_SUCCESS);
922
923 res = credentialOperator->deleteCredential(reqJsonStr, &returnData);
924 ASSERT_NE(res, HC_SUCCESS);
925 }
926
927 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest018, TestSize.Level0)
928 {
929 SetIsoSupported(false);
930 SetPakeV1Supported(true);
931 SetDeviceStatus(true);
932
933 const CredentialOperator *credentialOperator = GetCredentialOperator();
934
935 const char *reqJsonStr = "{\"deviceId\":\"123456\",\"osAccountId\":0}";
936 char *returnData = nullptr;
937 int32_t res = credentialOperator->queryCredential(reqJsonStr, &returnData);
938 ASSERT_NE(res, HC_SUCCESS);
939
940 res = credentialOperator->genarateCredential(reqJsonStr, &returnData);
941 ASSERT_NE(res, HC_SUCCESS);
942
943 res = credentialOperator->importCredential(reqJsonStr, &returnData);
944 ASSERT_NE(res, HC_SUCCESS);
945
946 res = credentialOperator->deleteCredential(reqJsonStr, &returnData);
947 ASSERT_NE(res, HC_SUCCESS);
948 }
949
950 // auth with pin (Test019 ~ Test027)
951 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest019, TestSize.Level0)
952 {
953 SetIsoSupported(false);
954 SetPakeV1Supported(true);
955 SetDeviceStatus(true);
956 AuthDeviceDirectWithPinDemo(AUTH_WITH_PIN_PARAMS, nullptr);
957 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
958 }
959
960 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest020, TestSize.Level0)
961 {
962 SetIsoSupported(false);
963 SetPakeV1Supported(true);
964 SetDeviceStatus(true);
965 AuthDeviceDirectWithPinDemo(nullptr, &g_daTmpCallback);
966 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
967 }
968
969 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest021, TestSize.Level0)
970 {
971 SetIsoSupported(false);
972 SetPakeV1Supported(true);
973 SetDeviceStatus(true);
974 const char *startAuthParams = "{\"osAccountId\":100,\"acquireType\":1,\"pinCode\":\"123456\"}";
975 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
976 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
977 }
978
979 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest022, TestSize.Level0)
980 {
981 SetIsoSupported(false);
982 SetPakeV1Supported(true);
983 SetDeviceStatus(true);
984 const char *startAuthParams = "{\"acquireType\":0,\"pinCode\":\"123456\"}";
985 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
986 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
987 }
988
989 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest023, TestSize.Level0)
990 {
991 SetIsoSupported(false);
992 SetPakeV1Supported(true);
993 SetDeviceStatus(true);
994 const char *startAuthParams = "{\"osAccountId\":-2,\"acquireType\":0,\"pinCode\":\"123456\"}";
995 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
996 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
997 }
998
999 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest024, TestSize.Level0)
1000 {
1001 SetIsoSupported(false);
1002 SetPakeV1Supported(true);
1003 SetDeviceStatus(true);
1004 const char *startAuthParams = "{\"osAccountId\":-1,\"acquireType\":0,\"pinCode\":\"123456\"}";
1005 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
1006 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1007 }
1008
1009 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest025, TestSize.Level0)
1010 {
1011 SetIsoSupported(false);
1012 SetPakeV1Supported(true);
1013 SetDeviceStatus(true);
1014 const char *startAuthParams = "{\"osAccountId\":0,\"acquireType\":0,\"pinCode\":\"654321\"}";
1015 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
1016 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1017 }
1018
1019 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest026, TestSize.Level0)
1020 {
1021 SetIsoSupported(false);
1022 SetPakeV1Supported(true);
1023 SetDeviceStatus(true);
1024 const char *startAuthParams = "{\"osAccountId\":100,\"acquireType\":0}";
1025 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
1026 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1027 }
1028
1029 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest027, TestSize.Level0)
1030 {
1031 SetIsoSupported(false);
1032 SetPakeV1Supported(true);
1033 SetDeviceStatus(true);
1034 const char *startAuthParams = "{\"osAccountId\":100,\"pinCode\":\"123456\"}";
1035 AuthDeviceDirectWithPinDemo(startAuthParams, &g_daTmpCallback);
1036 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1037 }
1038
1039 // auth with key-pair (Test028 ~ Test032)
1040 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest028, TestSize.Level0)
1041 {
1042 DeleteAllCredentails();
1043 SetIsoSupported(false);
1044 SetPakeV1Supported(true);
1045 SetDeviceStatus(true);
1046 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
1047 AuthDeviceDirectDemo(AUTH_DIRECT_PARAMS, &g_daLTCallback);
1048 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1049 }
1050
1051 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest029, TestSize.Level0)
1052 {
1053 DeleteAllCredentails();
1054 SetIsoSupported(false);
1055 SetPakeV1Supported(true);
1056 SetDeviceStatus(true);
1057 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
1058 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER);
1059 char *publicKey = nullptr;
1060 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER, &publicKey);
1061 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_SERVER, publicKey);
1062 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT, &publicKey);
1063 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_CLIENT, publicKey);
1064 AuthDeviceDirectDemo(AUTH_DIRECT_PARAMS, &g_daLTCallback);
1065 ASSERT_EQ(g_asyncStatus, ASYNC_STATUS_FINISH);
1066 }
1067
1068 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest030, TestSize.Level0)
1069 {
1070 DeleteAllCredentails();
1071 SetIsoSupported(false);
1072 SetPakeV1Supported(true);
1073 SetDeviceStatus(true);
1074 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
1075 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER);
1076 char *publicKey = nullptr;
1077 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER, &publicKey);
1078 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_SERVER, publicKey);
1079 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT, &publicKey);
1080 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_CLIENT, publicKey);
1081 const char *statAuthParams =
1082 "{\"osAccountId\":100,\"acquireType\":0,\"serviceType\":\"service.type.import\"}";
1083 AuthDeviceDirectDemo(statAuthParams, &g_daLTCallback);
1084 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1085 }
1086
1087 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest031, TestSize.Level0)
1088 {
1089 DeleteAllCredentails();
1090 SetIsoSupported(false);
1091 SetPakeV1Supported(true);
1092 SetDeviceStatus(true);
1093 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
1094 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER);
1095 char *publicKey = nullptr;
1096 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER, &publicKey);
1097 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_SERVER, publicKey);
1098 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT, &publicKey);
1099 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_CLIENT, publicKey);
1100 const char *statAuthParams =
1101 "{\"osAccountId\":100,\"acquireType\":0,\"serviceType\":\"service.type.import\",\"peerConnDeviceId\":"
1102 "\"52E2706717D5C39D736E134CC1\"}";
1103 AuthDeviceDirectDemo(statAuthParams, &g_daLTCallback);
1104 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1105 }
1106
1107 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest032, TestSize.Level0)
1108 {
1109 DeleteAllCredentails();
1110 SetIsoSupported(false);
1111 SetPakeV1Supported(true);
1112 SetDeviceStatus(true);
1113 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT);
1114 ProcessCredentiaCreateDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER);
1115 char *publicKey = nullptr;
1116 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_SERVER, &publicKey);
1117 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_SERVER, publicKey);
1118 ProcessCredentialQueryDemo(TEST_AUTH_OS_ACCOUNT_ID, true, TEST_UDID_CLIENT, &publicKey);
1119 ProcessCredentialDemoImpPubKey(TEST_AUTH_OS_ACCOUNT_ID, false, TEST_UDID_CLIENT, publicKey);
1120 const char *statAuthParams =
1121 "{\"osAccountId\":100,\"acquireType\":8,\"serviceType\":\"service.type.import\",\"peerConnDeviceId\":"
1122 "\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C"
1123 "749558BD2E6492C\"}";
1124 AuthDeviceDirectDemo(statAuthParams, &g_daLTCallback);
1125 ASSERT_NE(g_asyncStatus, ASYNC_STATUS_FINISH);
1126 }
1127 } // namespace
1128