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