1 /*
2 * Copyright (C) 2023 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 <cstring>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include "device_auth.h"
21 #include "device_auth_defines.h"
22 #include "json_utils.h"
23 #include "securec.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26 #include "hc_dev_info.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 #define PROC_NAME_DEVICE_MANAGER "device_manager"
33 #define TEST_REQ_ID 123
34 #define TEST_OS_ACCOUNT_ID 100
35 #define TEST_RANDOM_LEN 16
36 #define TEST_APP_ID "TestAppId"
37 #define TEST_APP_ID2 "TestAppId2"
38 #define TEST_UDID "TestUdid"
39 #define TEST_UDID_CLIENT "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
40 #define TEST_UDID_SERVER "52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C"
41 #define TEST_PIN_CODE "123456"
42
43 static const char* AUTH_WITH_PIN_PARAMS = "{\"osAccountId\":100,\"acquireType\":0,\"pinCode\":\"123456\"}";
44 static const char* AUTH_DIRECT_PARAMS =
45 "{\"osAccountId\":100,\"acquireType\":0,\"serviceType\":\"service.type.import\",\"peerConnDeviceId\":"
46 "\"52E2706717D5C39D736E134CC1E3BE1BAA2AA52DB7C76A37C749558BD2E6492C\"}";
47 static const char *TEST_CLIENT_PK = "3059301306072A8648CE3D020106082A8648CE3D030107034200042CFE425AB037B9E6F"
48 "837AED32F0CD4460D509E8C6AEC3A5D49DB25F2DDC133A87434BFDD34";
49 static const char *TEST_SERVER_PK = "020106082A8648CE3D030107034200042CFE425AB037B9E6F837AED32F0CD4460D509E8"
50 "C6AEC3A5D49DB25F2DDC133A87434BFDD34563C2226F838D3951C0F3D";
51 #define FIELD_PUBLIC_KEY "publicKey"
52 #define FIELD_PIN_CODE "pinCode"
53 #define SERVICE_TYPE_IMPORT "service.type.import"
54 #define DEFAULT_SERVICE_TYPE "service.type.default"
55
56 enum AsyncStatus {
57 ASYNC_STATUS_WAITING = 0,
58 ASYNC_STATUS_TRANSMIT = 1,
59 ASYNC_STATUS_FINISH = 2,
60 ASYNC_STATUS_ERROR = 3
61 };
62
63 static AsyncStatus volatile g_asyncStatus;
64 static uint32_t g_transmitDataMaxLen = 2048;
65 static uint8_t g_transmitData[2048] = { 0 };
66 static uint32_t g_transmitDataLen = 0;
67
NativeTokenSet(const char * procName)68 static void NativeTokenSet(const char *procName)
69 {
70 const char *acls[] = {"ACCESS_IDS"};
71 const char *perms[] = {
72 "ohos.permission.PLACE_CALL",
73 "ohos.permission.ACCESS_IDS"
74 };
75 uint64_t tokenId;
76 NativeTokenInfoParams infoInstance = {
77 .dcapsNum = 0,
78 .permsNum = 2,
79 .aclsNum = 1,
80 .dcaps = NULL,
81 .perms = perms,
82 .acls = acls,
83 .processName = procName,
84 .aplStr = "system_core",
85 };
86 tokenId = GetAccessTokenId(&infoInstance);
87 SetSelfTokenID(tokenId);
88 }
89
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)90 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
91 {
92 if (memcpy_s(g_transmitData, g_transmitDataMaxLen, data, dataLen) != EOK) {
93 return false;
94 }
95 g_transmitDataLen = dataLen;
96 g_asyncStatus = ASYNC_STATUS_TRANSMIT;
97 return true;
98 }
99
OnSessionKeyReturned(int64_t requestId,const uint8_t * sessionKey,uint32_t sessionKeyLen)100 static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
101 {
102 (void)requestId;
103 (void)sessionKey;
104 (void)sessionKeyLen;
105 return;
106 }
107
OnFinish(int64_t requestId,int operationCode,const char * authReturn)108 static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
109 {
110 g_asyncStatus = ASYNC_STATUS_FINISH;
111 }
112
OnError(int64_t requestId,int operationCode,int errorCode,const char * errorReturn)113 static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
114 {
115 g_asyncStatus = ASYNC_STATUS_ERROR;
116 }
117
OnAuthRequestDirectTmp(int64_t requestId,int operationCode,const char * reqParam)118 static char *OnAuthRequestDirectTmp(int64_t requestId, int operationCode, const char *reqParam)
119 {
120 CJson *json = CreateJson();
121 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
122 AddStringToJson(json, FIELD_PIN_CODE, TEST_PIN_CODE);
123 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
124 char *returnDataStr = PackJsonToString(json);
125 FreeJson(json);
126 return returnDataStr;
127 }
128
OnAuthRequestDirect(int64_t requestId,int operationCode,const char * reqParam)129 static char *OnAuthRequestDirect(int64_t requestId, int operationCode, const char *reqParam)
130 {
131 CJson *json = CreateJson();
132 AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED);
133 AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, TEST_UDID_CLIENT);
134 AddStringToJson(json, FIELD_SERVICE_TYPE, SERVICE_TYPE_IMPORT);
135 char *returnDataStr = PackJsonToString(json);
136 FreeJson(json);
137 return returnDataStr;
138 }
139
140 static DeviceAuthCallback g_daTmpCallback = {
141 .onTransmit = OnTransmit,
142 .onSessionKeyReturned = OnSessionKeyReturned,
143 .onFinish = OnFinish,
144 .onError = OnError,
145 .onRequest = OnAuthRequestDirectTmp
146 };
147
148 static DeviceAuthCallback g_daLTCallback = {
149 .onTransmit = OnTransmit,
150 .onSessionKeyReturned = OnSessionKeyReturned,
151 .onFinish = OnFinish,
152 .onError = OnError,
153 .onRequest = OnAuthRequestDirect
154 };
155
CreateCredentialParamsJson(int32_t osAccountId,const char * deviceId,int32_t flag,const char * serviceType,CJson * out)156 static void CreateCredentialParamsJson(
157 int32_t osAccountId, const char *deviceId, int32_t flag,
158 const char *serviceType, CJson *out)
159 {
160 AddIntToJson(out, FIELD_OS_ACCOUNT_ID, osAccountId);
161 AddStringToJson(out, FIELD_DEVICE_ID, deviceId);
162 AddStringToJson(out, FIELD_SERVICE_TYPE, serviceType);
163 AddIntToJson(out, FIELD_ACQURIED_TYPE, P2P_BIND);
164
165 if (flag >= 0) {
166 AddIntToJson(out, FIELD_CRED_OP_FLAG, flag);
167 }
168 return;
169 }
170
GetSelfUdid(char ** selfUdid)171 static int32_t GetSelfUdid(char **selfUdid)
172 {
173 printf("%s called.\n", __FUNCTION__);
174 char udid[INPUT_UDID_LEN] = { 0 };
175 int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN);
176 if (res != HC_SUCCESS) {
177 printf("Failed to get self udid! res: %d", res);
178 return res;
179 }
180
181 printf("self udid: %s\n", udid);
182 *selfUdid = strdup(udid);
183 return HC_SUCCESS;
184 }
185
CreateServerKeyPair()186 static int32_t CreateServerKeyPair()
187 {
188 char *selfUdid = nullptr;
189 int32_t res = GetSelfUdid(&selfUdid);
190 if (res != HC_SUCCESS) {
191 return res;
192 }
193 CJson *json = CreateJson();
194 if (json == nullptr) {
195 printf("Failed to create json!\n");
196 free(selfUdid);
197 return HC_ERR_JSON_CREATE;
198 }
199 CreateCredentialParamsJson(TEST_OS_ACCOUNT_ID, selfUdid, RETURN_FLAG_PUBLIC_KEY,
200 DEFAULT_SERVICE_TYPE, json);
201 char *requestParams = PackJsonToString(json);
202 FreeJson(json);
203 free(selfUdid);
204 if (requestParams == nullptr) {
205 printf("Failed to pack json to string!\n");
206 return HC_ERR_PACKAGE_JSON_TO_STRING_FAIL;
207 }
208 char *returnData = nullptr;
209
210 printf("ProcessCredentialDemo: operationCode=%d\n", CRED_OP_CREATE);
211 res = ProcessCredential(CRED_OP_CREATE, requestParams, &returnData);
212 FreeJsonString(requestParams);
213 if (returnData) {
214 printf("returnData: %s\n", returnData);
215 CJson *in = CreateJsonFromString(returnData);
216 if (in == nullptr) {
217 printf("CreateJsonFromString returnData failed !\n");
218 } else {
219 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
220 printf("GetIntFromJson result failed !\n");
221 FreeJson(in);
222 return HC_ERR_INVALID_PARAMS;
223 }
224 printf("get result from returnData: %d\n", res);
225 return res;
226 }
227 }
228
229 printf("returnData is null !\n");
230
231 return res;
232 }
233
DeleteServerKeyPair()234 static int32_t DeleteServerKeyPair()
235 {
236 char *selfUdid = nullptr;
237 int32_t res = GetSelfUdid(&selfUdid);
238 if (res != HC_SUCCESS) {
239 return res;
240 }
241 CJson *json = CreateJson();
242 if (json == nullptr) {
243 printf("Failed to create json!\n");
244 free(selfUdid);
245 return HC_ERR_ALLOC_MEMORY;
246 }
247 CreateCredentialParamsJson(TEST_OS_ACCOUNT_ID, selfUdid, 1, DEFAULT_SERVICE_TYPE, json);
248 char *requestParams = PackJsonToString(json);
249 FreeJson(json);
250 free(selfUdid);
251 if (requestParams == nullptr) {
252 printf("Failed to pack json to string!\n");
253 return HC_ERR_PACKAGE_JSON_TO_STRING_FAIL;
254 }
255 char *returnData = nullptr;
256
257 printf("ProcessCredentialDemo: operationCode=%d\n", CRED_OP_DELETE);
258 res = ProcessCredential(CRED_OP_DELETE, requestParams, &returnData);
259 FreeJsonString(requestParams);
260 if (returnData) {
261 printf("returnData: %s\n", returnData);
262 CJson *in = CreateJsonFromString(returnData);
263 if (in == nullptr) {
264 printf("CreateJsonFromString returnData failed !\n");
265 } else {
266 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
267 printf("GetIntFromJson result failed !\n");
268 FreeJson(in);
269 return HC_ERR_INVALID_PARAMS;
270 }
271 printf("get result from returnData: %d\n", res);
272 return res;
273 }
274 }
275
276 printf("returnData is null !\n");
277
278 return res;
279 }
280
ProcessCredentialDemo(int operationCode,const char * serviceType)281 static int32_t ProcessCredentialDemo(int operationCode, const char *serviceType)
282 {
283 int32_t flag = -1;
284 if (operationCode == CRED_OP_CREATE || operationCode == CRED_OP_QUERY) {
285 flag = 1;
286 }
287 CJson *json = CreateJson();
288 if (json == NULL) {
289 return HC_ERR_ALLOC_MEMORY;
290 }
291 CreateCredentialParamsJson(TEST_OS_ACCOUNT_ID, TEST_UDID, flag, serviceType, json);
292 char *requestParams = PackJsonToString(json);
293 FreeJson(json);
294 char *returnData = nullptr;
295
296 printf("ProcessCredentialDemo: operationCode=%d\n", operationCode);
297 int32_t res = ProcessCredential(operationCode, requestParams, &returnData);
298 FreeJsonString(requestParams);
299 if (returnData) {
300 printf("returnData: %s\n", returnData);
301 CJson *in = CreateJsonFromString(returnData);
302 if (in == nullptr) {
303 printf("CreateJsonFromString returnData failed !\n");
304 } else {
305 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
306 printf("GetIntFromJson result failed !\n");
307 FreeJson(in);
308 return HC_ERR_INVALID_PARAMS;
309 }
310 printf("get result from returnData: %d\n", res);
311 return res;
312 }
313 }
314
315 printf("returnData is null !\n");
316
317 return res;
318 }
319
ProcessCredentialDemoImport(const char * importServiceType)320 static int32_t ProcessCredentialDemoImport(const char *importServiceType)
321 {
322 CJson *json = CreateJson();
323 if (json == NULL) {
324 return HC_ERR_ALLOC_MEMORY;
325 }
326 CreateCredentialParamsJson(TEST_OS_ACCOUNT_ID, TEST_UDID, -1, importServiceType, json);
327 AddStringToJson(json, FIELD_PUBLIC_KEY,
328 "CA32A9DFACB944B1F6292C9AE10783F6376A987A9CE30C13300BC866917DFF2E");
329 char *requestParams = PackJsonToString(json);
330 FreeJson(json);
331 char *returnData = nullptr;
332
333 printf("ProcessCredentialDemoImport\n");
334 int32_t res = ProcessCredential(CRED_OP_IMPORT, requestParams, &returnData);
335 FreeJsonString(requestParams);
336 if (returnData) {
337 CJson *in = CreateJsonFromString(returnData);
338 if (in == nullptr) {
339 printf("CreateJsonFromString returnData failed !\n");
340 } else {
341 if (GetIntFromJson(in, FIELD_CRED_OP_RESULT, &res) != HC_SUCCESS) {
342 printf("GetIntFromJson result failed !\n");
343 FreeJson(in);
344 return HC_ERR_INVALID_PARAMS;
345 }
346 printf("get result from returnData: %d\n", res);
347 return res;
348 }
349 }
350
351 printf("returnData is null !\n");
352
353 return res;
354 }
355
356 class DaAuthDeviceTest : public testing::Test {
357 public:
358 static void SetUpTestCase();
359 static void TearDownTestCase();
360 void SetUp();
361 void TearDown();
362 };
363
SetUpTestCase()364 void DaAuthDeviceTest::SetUpTestCase() {}
365
TearDownTestCase()366 void DaAuthDeviceTest::TearDownTestCase() {}
367
SetUp()368 void DaAuthDeviceTest::SetUp()
369 {
370 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
371 int32_t ret = InitDeviceAuthService();
372 ASSERT_EQ(ret, HC_SUCCESS);
373 }
374
TearDown()375 void DaAuthDeviceTest::TearDown()
376 {
377 DestroyDeviceAuthService();
378 }
379
380 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest001, TestSize.Level0)
381 {
382 int32_t res = StartAuthDevice(TEST_REQ_ID, AUTH_WITH_PIN_PARAMS, &g_daTmpCallback);
383 ASSERT_EQ(res, HC_SUCCESS);
384 res = CancelAuthRequest(TEST_REQ_ID, AUTH_WITH_PIN_PARAMS);
385 ASSERT_EQ(res, HC_SUCCESS);
386 }
387
388 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest002, TestSize.Level0)
389 {
390 int32_t res = StartAuthDevice(TEST_REQ_ID, AUTH_DIRECT_PARAMS, &g_daLTCallback);
391 ASSERT_EQ(res, HC_SUCCESS);
392 res = CancelAuthRequest(TEST_REQ_ID, AUTH_DIRECT_PARAMS);
393 ASSERT_EQ(res, HC_SUCCESS);
394 }
395
396 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest003, TestSize.Level0)
397 {
398 int32_t res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
399 ASSERT_EQ(res, HC_SUCCESS);
400 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
401 ASSERT_NE(res, HC_SUCCESS);
402 res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
403 ASSERT_EQ(res, HC_SUCCESS);
404 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
405 ASSERT_EQ(res, HC_SUCCESS);
406 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
407 ASSERT_EQ(res, HC_SUCCESS);
408 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
409 ASSERT_NE(res, HC_SUCCESS);
410 }
411
412 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest004, TestSize.Level0)
413 {
414 int32_t res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
415 ASSERT_EQ(res, HC_SUCCESS);
416 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
417 ASSERT_EQ(res, HC_SUCCESS);
418 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
419 ASSERT_EQ(res, HC_SUCCESS);
420 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
421 ASSERT_NE(res, HC_SUCCESS);
422 }
423
424 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest005, TestSize.Level0)
425 {
426 int32_t res = CreateServerKeyPair();
427 ASSERT_EQ(res, HC_SUCCESS);
428 res = ProcessCredentialDemoImport(SERVICE_TYPE_IMPORT);
429 ASSERT_EQ(res, HC_SUCCESS);
430 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
431 ASSERT_EQ(res, HC_SUCCESS);
432 res = ProcessCredentialDemo(CRED_OP_DELETE, SERVICE_TYPE_IMPORT);
433 ASSERT_EQ(res, HC_SUCCESS);
434 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
435 ASSERT_NE(res, HC_SUCCESS);
436 res = DeleteServerKeyPair();
437 ASSERT_EQ(res, HC_SUCCESS);
438 }
439
440 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest006, TestSize.Level0)
441 {
442 int32_t res = CreateServerKeyPair();
443 ASSERT_EQ(res, HC_SUCCESS);
444 res = ProcessCredentialDemoImport(SERVICE_TYPE_IMPORT);
445 ASSERT_EQ(res, HC_SUCCESS);
446 res = ProcessCredentialDemoImport(SERVICE_TYPE_IMPORT);
447 ASSERT_EQ(res, HC_SUCCESS);
448 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
449 ASSERT_EQ(res, HC_SUCCESS);
450 res = ProcessCredentialDemo(CRED_OP_DELETE, SERVICE_TYPE_IMPORT);
451 ASSERT_EQ(res, HC_SUCCESS);
452 res = ProcessCredentialDemo(CRED_OP_QUERY, SERVICE_TYPE_IMPORT);
453 ASSERT_NE(res, HC_SUCCESS);
454 res = DeleteServerKeyPair();
455 ASSERT_EQ(res, HC_SUCCESS);
456 }
457
458 HWTEST_F(DaAuthDeviceTest, DaAuthDeviceTest007, TestSize.Level0)
459 {
460 int32_t res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
461 ASSERT_EQ(res, HC_SUCCESS);
462 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
463 ASSERT_EQ(res, HC_SUCCESS);
464 res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
465 ASSERT_NE(res, HC_SUCCESS);
466 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
467 ASSERT_EQ(res, HC_SUCCESS);
468 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
469 ASSERT_NE(res, HC_SUCCESS);
470 }
471
472 class ApiAccessBlockTest : public testing::Test {
473 public:
474 static void SetUpTestCase();
475 static void TearDownTestCase();
476 void SetUp();
477 void TearDown();
478 };
479
SetUpTestCase()480 void ApiAccessBlockTest::SetUpTestCase() {}
481
TearDownTestCase()482 void ApiAccessBlockTest::TearDownTestCase() {}
483
SetUp()484 void ApiAccessBlockTest::SetUp()
485 {
486 NativeTokenSet(TEST_APP_ID2);
487 int32_t ret = InitDeviceAuthService();
488 ASSERT_EQ(ret, HC_SUCCESS);
489 }
490
TearDown()491 void ApiAccessBlockTest::TearDown()
492 {
493 DestroyDeviceAuthService();
494 }
495
496 HWTEST_F(ApiAccessBlockTest, ApiAccessBlockTest001, TestSize.Level0)
497 {
498 int32_t res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
499 ASSERT_NE(res, HC_SUCCESS);
500 }
501
502 class ApiAccessPassTest : public testing::Test {
503 public:
504 static void SetUpTestCase();
505 static void TearDownTestCase();
506 void SetUp();
507 void TearDown();
508 };
509
SetUpTestCase()510 void ApiAccessPassTest::SetUpTestCase() {}
511
TearDownTestCase()512 void ApiAccessPassTest::TearDownTestCase() {}
513
SetUp()514 void ApiAccessPassTest::SetUp()
515 {
516 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
517 int32_t ret = InitDeviceAuthService();
518 ASSERT_EQ(ret, HC_SUCCESS);
519 }
520
TearDown()521 void ApiAccessPassTest::TearDown()
522 {
523 DestroyDeviceAuthService();
524 }
525
526 HWTEST_F(ApiAccessPassTest, ApiAccessPassTest001, TestSize.Level0)
527 {
528 int32_t res = ProcessCredentialDemo(CRED_OP_CREATE, DEFAULT_SERVICE_TYPE);
529 ASSERT_EQ(res, HC_SUCCESS);
530 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
531 ASSERT_EQ(res, HC_SUCCESS);
532 res = ProcessCredentialDemo(CRED_OP_DELETE, DEFAULT_SERVICE_TYPE);
533 ASSERT_EQ(res, HC_SUCCESS);
534 res = ProcessCredentialDemo(CRED_OP_QUERY, DEFAULT_SERVICE_TYPE);
535 ASSERT_NE(res, HC_SUCCESS);
536 }
537
538 class AccountVerifyTest : public testing::Test {
539 public:
540 static void SetUpTestCase();
541 static void TearDownTestCase();
542 void SetUp();
543 void TearDown();
544 };
545
SetUpTestCase()546 void AccountVerifyTest::SetUpTestCase() {}
547
TearDownTestCase()548 void AccountVerifyTest::TearDownTestCase() {}
549
SetUp()550 void AccountVerifyTest::SetUp()
551 {
552 NativeTokenSet(PROC_NAME_DEVICE_MANAGER);
553 int32_t ret = InitDeviceAuthService();
554 ASSERT_EQ(ret, HC_SUCCESS);
555 }
556
TearDown()557 void AccountVerifyTest::TearDown()
558 {
559 DestroyDeviceAuthService();
560 }
561
562 HWTEST_F(AccountVerifyTest, AccountVerifyTest001, TestSize.Level0)
563 {
564 const AccountVerifier *verifier = GetAccountVerifierInstance();
565 ASSERT_NE(verifier, nullptr);
566 DataBuff sharedKeyBuff = { nullptr, 0 };
567 DataBuff randomBuff = { nullptr, 0 };
568 int32_t res = verifier->getClientSharedKey(nullptr, nullptr, nullptr, nullptr);
569 ASSERT_NE(res, HC_SUCCESS);
570 res = verifier->getClientSharedKey(TEST_SERVER_PK, nullptr, nullptr, nullptr);
571 ASSERT_NE(res, HC_SUCCESS);
572 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, nullptr, nullptr);
573 ASSERT_NE(res, HC_SUCCESS);
574 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, &sharedKeyBuff, nullptr);
575 ASSERT_NE(res, HC_SUCCESS);
576 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, &sharedKeyBuff, &randomBuff);
577 ASSERT_NE(res, HC_SUCCESS);
578 res = verifier->getServerSharedKey(nullptr, nullptr, nullptr, nullptr);
579 ASSERT_NE(res, HC_SUCCESS);
580 res = verifier->getServerSharedKey(TEST_CLIENT_PK, nullptr, nullptr, nullptr);
581 ASSERT_NE(res, HC_SUCCESS);
582 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, nullptr, nullptr);
583 ASSERT_NE(res, HC_SUCCESS);
584 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, nullptr);
585 ASSERT_NE(res, HC_SUCCESS);
586 uint8_t randomVal[TEST_RANDOM_LEN] = { 0 };
587 randomBuff.data = randomVal;
588 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, nullptr);
589 ASSERT_NE(res, HC_SUCCESS);
590 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, &sharedKeyBuff);
591 ASSERT_NE(res, HC_SUCCESS);
592 randomBuff.length = TEST_RANDOM_LEN;
593 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, &sharedKeyBuff);
594 ASSERT_NE(res, HC_SUCCESS);
595 verifier->destroyDataBuff(nullptr);
596 verifier->destroyDataBuff(&sharedKeyBuff);
597 }
598 }
599