1 /*
2 * Copyright (C) 2024-2025 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 "device_auth.h"
21 #include "device_auth_defines.h"
22 #include "device_auth_ext.h"
23 #include "account_auth_plugin_proxy.h"
24 #include "pake_protocol_dl_common.h"
25 #include "pake_v1_protocol_task_common.h"
26 #include "ipc_adapt.h"
27 #include "json_utils.h"
28 #include "alg_loader.h"
29 #include "mk_agree_task.h"
30 #include "ext_plugin_manager.h"
31 #include "channel_manager.h"
32 #include "soft_bus_channel.h"
33 #include "dev_auth_module_manager.h"
34 #include "mbedtls_ec_adapter.h"
35 #include "account_task_main.h"
36 #include "account_version_util.h"
37 #include "account_module.h"
38 #include "account_multi_task_manager.h"
39 #include "account_task_manager.h"
40 #include "identical_account_group.h"
41 #include "broadcast_manager.h"
42 #include "iso_protocol_common.h"
43 #include "das_lite_token_manager.h"
44 #include "das_standard_token_manager.h"
45 #include "key_manager.h"
46 #include "group_auth_data_operation.h"
47 #include "compatible_bind_sub_session_util.h"
48 #include "compatible_bind_sub_session.h"
49 #include "compatible_auth_sub_session_common.h"
50 #include "compatible_auth_sub_session_util.h"
51 #include "account_unrelated_group_auth.h"
52 #include "das_task_common.h"
53 #include "das_version_util.h"
54 #include "pake_v1_protocol_common.h"
55 #include "dev_session_util.h"
56 #include "pake_v2_protocol_common.h"
57 #include "iso_task_common.h"
58 #include "../../../../services/legacy/authenticators/src/account_unrelated/pake_task/pake_v1_task/pake_v1_protocol_task/pake_v1_protocol_task_common.c"
59 #include "../../../../services/session_manager/src/session/v2/dev_session_util.c"
60 #include "../../../../services/legacy/group_manager/src/group_operation/identical_account_group/identical_account_group.c"
61
62 using namespace std;
63 using namespace testing::ext;
64
65 namespace {
66 #define TEST_PSEUDONYM_ID "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
67 #define TEST_PSEUDONYM_CHALLENGE "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
68 #define TEST_CONNECT_PARAMS "TestConnectParams"
69 #define TEST_TRANSMIT_DATA "TestTransmitData"
70 #define TEST_APP_ID "TestAppId"
71 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
72 #define TEST_USER_ID "testUserId"
73 #define TEST_DEVICE_ID "testDeviceId"
74 #define TEST_PK_INFO "TestPkInfo"
75 #define TEST_PK_INFO_SIGN "TestPkInfoSign"
76 #define TEST_AUTH_ID "TestAuthId"
77 #define TEST_KEY_LEN_1 10
78 #define TEST_KEY_LEN_2 40
79 #define TEST_OS_ACCOUNT_ID 0
80 #define TEST_DEVICE_PK "testDevicePk"
81 #define TEST_VERSION 0
82 #define TEST_RANDOM_LEN 16
83 static const char *EXT_INFO =
84 "{\"credType\":1,\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
85 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
86 "\"deviceId\":\"TestDeviceId\",\"credOwner\":\"TestAppId\","
87 "\"authorizedAccoutList\":[\"TestName1\",\"TestName2\",\"TestName3\"],"
88 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
89 static const char *CRED_DATA =
90 "{\"keyFormat\":4,\"algorithmType\":3,\"subject\":1,\"issuer\":1,"
91 "\"proofType\":1,\"method\":1,\"authorizedScope\":1,\"userId\":\"TestUserId\","
92 "\"peerUserSpaceId\":100,\"extendInfo\":\"\"}";
93 static const char *TEST_CLIENT_PK = "3059301306072A8648CE3D020106082A8648CE3D030107034200042CFE425AB037B9E6F"
94 "837AED32F0CD4460D509E8C6AEC3A5D49DB25F2DDC133A87434BFDD34";
95 static const char *TEST_SERVER_PK = "020106082A8648CE3D030107034200042CFE425AB037B9E6F837AED32F0CD4460D509E8"
96 "C6AEC3A5D49DB25F2DDC133A87434BFDD34563C2226F838D3951C0F3D";
97
98 class DeviceAuthInterfaceTest : public testing::Test {
99 public:
100 static void SetUpTestCase();
101 static void TearDownTestCase();
102 void SetUp();
103 void TearDown();
104 };
105
SetUpTestCase()106 void DeviceAuthInterfaceTest::SetUpTestCase() {}
TearDownTestCase()107 void DeviceAuthInterfaceTest::TearDownTestCase() {}
SetUp()108 void DeviceAuthInterfaceTest::SetUp() {}
TearDown()109 void DeviceAuthInterfaceTest::TearDown() {}
110
CreateSessionTest(int32_t * sessionId,const cJSON * in,cJSON * out)111 static int32_t CreateSessionTest(int32_t *sessionId, const cJSON *in, cJSON *out)
112 {
113 (void)sessionId;
114 (void)in;
115 (void)out;
116 return HC_SUCCESS;
117 }
118
ExcuteCredMgrCmdTest(int32_t osAccount,int32_t cmdId,const cJSON * in,cJSON * out)119 static int32_t ExcuteCredMgrCmdTest(int32_t osAccount, int32_t cmdId, const cJSON *in, cJSON *out)
120 {
121 (void)osAccount;
122 (void)cmdId;
123 (void)in;
124 (void)out;
125 return HC_SUCCESS;
126 }
127
ProcessSessionTest(int32_t * sessionId,const cJSON * in,cJSON * out,int32_t * status)128 static int32_t ProcessSessionTest(int32_t *sessionId, const cJSON *in, cJSON *out, int32_t *status)
129 {
130 (void)sessionId;
131 (void)in;
132 (void)out;
133 (void)status;
134 return HC_SUCCESS;
135 }
136
DestroySessionTest(int32_t sessionId)137 static int32_t DestroySessionTest(int32_t sessionId)
138 {
139 (void)sessionId;
140 return HC_SUCCESS;
141 }
142
InitTest(struct ExtPlugin * extPlugin,const cJSON * params,const struct ExtPluginCtx * context)143 static int32_t InitTest(struct ExtPlugin *extPlugin, const cJSON *params, const struct ExtPluginCtx *context)
144 {
145 (void)extPlugin;
146 (void)params;
147 (void)context;
148 return HC_SUCCESS;
149 }
150
Destroy(struct ExtPlugin * extPlugin)151 static void Destroy(struct ExtPlugin *extPlugin)
152 {
153 (void)extPlugin;
154 }
155
156 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest001, TestSize.Level0)
157 {
158 // account_auth_plugin_proxy.c interface test
159 int32_t res = SetAccountAuthPlugin(nullptr, nullptr);
160 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
161 res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
162 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
163 res = CreateAuthSession(0, nullptr, nullptr);
164 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
165 res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
166 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
167 res = DestroyAuthSession(0);
168 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
169 AccountAuthExtPlug plugin = { { 0 }, nullptr, nullptr, nullptr, nullptr };
170 res = SetAccountAuthPlugin(nullptr, &plugin);
171 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
172 res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
173 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
174 res = CreateAuthSession(0, nullptr, nullptr);
175 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
176 res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
177 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
178 res = DestroyAuthSession(0);
179 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
180 plugin.createSession = CreateSessionTest;
181 res = SetAccountAuthPlugin(nullptr, &plugin);
182 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
183 res = CreateAuthSession(0, nullptr, nullptr);
184 ASSERT_EQ(res, HC_SUCCESS);
185 plugin.excuteCredMgrCmd = ExcuteCredMgrCmdTest;
186 res = SetAccountAuthPlugin(nullptr, &plugin);
187 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
188 res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
189 ASSERT_EQ(res, HC_SUCCESS);
190 plugin.processSession = ProcessSessionTest;
191 res = SetAccountAuthPlugin(nullptr, &plugin);
192 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
193 res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
194 ASSERT_EQ(res, HC_SUCCESS);
195 plugin.destroySession = DestroySessionTest;
196 plugin.base.init = InitTest;
197 res = SetAccountAuthPlugin(nullptr, &plugin);
198 ASSERT_EQ(res, HC_SUCCESS);
199 res = DestroyAuthSession(0);
200 ASSERT_EQ(res, HC_SUCCESS);
201 DestoryAccountAuthPlugin();
202 }
203
204 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest002, TestSize.Level0)
205 {
206 // account_auth_plugin_proxy.c interface test
207 int32_t res = SetAccountAuthPlugin(nullptr, nullptr);
208 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
209 DestoryAccountAuthPlugin();
210 AccountAuthExtPlug plugin = { { 0 }, nullptr, nullptr, nullptr, nullptr };
211 res = SetAccountAuthPlugin(nullptr, &plugin);
212 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
213 DestoryAccountAuthPlugin();
214 plugin.base.destroy = Destroy;
215 res = SetAccountAuthPlugin(nullptr, &plugin);
216 ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
217 DestoryAccountAuthPlugin();
218 }
219
220 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest003, TestSize.Level0)
221 {
222 // pake_protocol_dl_common.c interface test
223 uint32_t alg = GetPakeDlAlg();
224 ASSERT_EQ(alg, PAKE_ALG_DL);
225 PakeBaseParams *baseParams = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
226 baseParams->loader = GetLoaderInstance();
227 baseParams->isClient = true;
228 int32_t res = GenerateDlPakeParams(baseParams, nullptr);
229 ASSERT_EQ(res, HC_ERR_INVALID_LEN);
230 baseParams->epkPeer.length = PAKE_DL_PRIME_LEN;
231 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
232 res = GenerateDlPakeParams(baseParams, nullptr);
233 ASSERT_NE(res, HC_SUCCESS);
234 baseParams->epkPeer.length = PAKE_DL_PRIME_SMALL_LEN;
235 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
236 ASSERT_NE(res, HC_SUCCESS);
237 baseParams->isClient = false;
238 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
239 res = GenerateDlPakeParams(baseParams, nullptr);
240 ASSERT_NE(res, HC_SUCCESS);
241 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
242 res = GenerateDlPakeParams(baseParams, nullptr);
243 ASSERT_NE(res, HC_SUCCESS);
244 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_NONE;
245 res = GenerateDlPakeParams(baseParams, nullptr);
246 ASSERT_NE(res, HC_SUCCESS);
247 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
248 uint8_t secretVal[16] = { 0 };
249 Uint8Buff secret = { secretVal, 16 };
250 res = GenerateDlPakeParams(baseParams, &secret);
251 ASSERT_EQ(res, HC_SUCCESS);
252 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_NONE;
253 res = AgreeDlSharedSecret(baseParams, nullptr);
254 ASSERT_NE(res, HC_SUCCESS);
255 baseParams->epkPeer.length = PAKE_DL_PRIME_LEN;
256 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
257 res = AgreeDlSharedSecret(baseParams, nullptr);
258 ASSERT_NE(res, HC_SUCCESS);
259 baseParams->epkPeer.length = PAKE_DL_PRIME_SMALL_LEN;
260 baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
261 res = AgreeDlSharedSecret(baseParams, nullptr);
262 ASSERT_NE(res, HC_SUCCESS);
263 HcFree(baseParams);
264 }
265
ConstructPakeV1InParams(CJson * in)266 static void ConstructPakeV1InParams(CJson *in)
267 {
268 (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
269 (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
270 (void)AddIntToJson(in, FIELD_SELF_TYPE, 0);
271 (void)AddStringToJson(in, FIELD_PKG_NAME, "testPkgName");
272 (void)AddStringToJson(in, FIELD_SERVICE_TYPE, "TestServiceType");
273 (void)AddStringToJson(in, FIELD_SELF_AUTH_ID, "TestAuthId");
274 (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, "TestPeerAuthId");
275 (void)AddBoolToJson(in, FIELD_IS_SELF_FROM_UPGRADE, true);
276 (void)AddBoolToJson(in, FIELD_IS_PEER_FROM_UPGRADE, true);
277 }
278
279 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest004, TestSize.Level0)
280 {
281 // pake_v1_protocol_task_common.c interface test
282 DestroyDasPakeV1Params(nullptr);
283 PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
284 params->pseudonymExtInfo.selfNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
285 ASSERT_NE(params->pseudonymExtInfo.selfNextPseudonymId.val, nullptr);
286 params->pseudonymExtInfo.selfNextPseudonymChallenge.val = (uint8_t *)HcMalloc(16, 0);
287 ASSERT_NE(params->pseudonymExtInfo.selfNextPseudonymChallenge.val, nullptr);
288 params->pseudonymExtInfo.peerNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
289 ASSERT_NE(params->pseudonymExtInfo.peerNextPseudonymId.val, nullptr);
290 DestroyDasPakeV1Params(params);
291 CJson *in = CreateJson();
292 ASSERT_NE(in, nullptr);
293 int32_t res = InitDasPakeV1Params(params, in);
294 ASSERT_NE(res, HC_SUCCESS);
295 ConstructPakeV1InParams(in);
296 res = InitDasPakeV1Params(params, in);
297 ASSERT_EQ(res, HC_SUCCESS);
298 res = LoadPseudonymExtInfoIfNeed(nullptr);
299 ASSERT_NE(res, HC_SUCCESS);
300 res = LoadPseudonymExtInfoIfNeed(params);
301 ASSERT_NE(res, HC_SUCCESS);
302 res = AddPseudonymIdAndChallenge(nullptr, nullptr);
303 ASSERT_NE(res, HC_SUCCESS);
304 res = AddPseudonymIdAndChallenge(params, nullptr);
305 ASSERT_NE(res, HC_SUCCESS);
306 CJson *payload = CreateJson();
307 ASSERT_NE(payload, nullptr);
308 res = AddPseudonymIdAndChallenge(params, payload);
309 ASSERT_NE(res, HC_SUCCESS);
310 res = CheckPseudonymId(nullptr, nullptr);
311 ASSERT_NE(res, HC_SUCCESS);
312 res = CheckPseudonymId(params, nullptr);
313 ASSERT_NE(res, HC_SUCCESS);
314 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
315 res = CheckPseudonymId(params, in);
316 ASSERT_NE(res, HC_SUCCESS);
317 (void)AddStringToJson(payload, FIELD_P2P_PSEUDONYM_ID, TEST_PSEUDONYM_ID);
318 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
319 res = CheckPseudonymId(params, in);
320 ASSERT_NE(res, HC_SUCCESS);
321 (void)AddStringToJson(payload, FIELD_PSEUDONYM_CHALLENGE, TEST_PSEUDONYM_CHALLENGE);
322 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
323 res = CheckPseudonymId(params, in);
324 ASSERT_NE(res, HC_SUCCESS);
325 FreeJson(in);
326 FreeJson(payload);
327 DestroyDasPakeV1Params(params);
328 HcFree(params);
329 }
330
331 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0041, TestSize.Level0)
332 {
333 // pake_v1_protocol_task_common.c static interface test
334 PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
335 params->opCode = OP_UNBIND;
336 CJson *in = CreateJson();
337 (void)AddIntToJson(in, FIELD_KEY_LENGTH, TEST_KEY_LEN_1);
338 int32_t res = AllocReturnKey(params, in);
339 EXPECT_EQ(res, HC_SUCCESS);
340
341 params->opCode = CODE_NULL;
342 (void)AddIntToJson(in, FIELD_KEY_LENGTH, TEST_KEY_LEN_1);
343 res = AllocReturnKey(params, in);
344 EXPECT_NE(res, HC_SUCCESS);
345
346 (void)AddIntToJson(in, FIELD_KEY_LENGTH, TEST_KEY_LEN_2);
347 res = AllocReturnKey(params, in);
348 EXPECT_NE(res, HC_SUCCESS);
349
350 DestroyDasPakeV1Params(params);
351 HcFree(params);
352 FreeJson(in);
353 }
354
355 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0042, TestSize.Level0)
356 {
357 // pake_v1_protocol_task_common.c static interface test
358 char *outStr = nullptr;
359 int32_t res = RemoveEscapeForExtInfo(EXT_INFO, &outStr);
360 EXPECT_EQ(res, HC_SUCCESS);
361 }
362
363 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0043, TestSize.Level0)
364 {
365 // pake_v1_protocol_task_common.c static interface test
366 PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
367 params->pseudonymExtInfo.selfNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
368 EXPECT_NE(params->pseudonymExtInfo.selfNextPseudonymId.val, nullptr);
369 params->pseudonymExtInfo.selfNextPseudonymChallenge.val = (uint8_t *)HcMalloc(16, 0);
370 EXPECT_NE(params->pseudonymExtInfo.selfNextPseudonymChallenge.val, nullptr);
371 params->pseudonymExtInfo.peerNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
372 EXPECT_NE(params->pseudonymExtInfo.peerNextPseudonymId.val, nullptr);
373 CJson *in = CreateJson();
374 uint8_t *selfNextIdVal = reinterpret_cast<uint8_t *>(HcMalloc(PSEUDONYM_ID_LEN, 0));
375 (void)AddByteToJson(in, FIELD_SELF_NEXT_PSEUDONYM_ID, selfNextIdVal, PSEUDONYM_ID_LEN);
376 int32_t res = FillPseudonymPskExtInfo(¶ms->pseudonymExtInfo, in);
377 EXPECT_NE(res, HC_SUCCESS);
378 HcFree(selfNextIdVal);
379 DestroyDasPakeV1Params(params);
380 HcFree(params);
381 FreeJson(in);
382 }
383
384 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0044, TestSize.Level0)
385 {
386 // pake_v1_protocol_task_common.c static interface test
387 PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
388 CJson *in = CreateJson();
389 int32_t res = CheckPseudonymId(params, in);
390 EXPECT_NE(res, HC_SUCCESS);
391 FreeJson(in);
392 DestroyDasPakeV1Params(params);
393 HcFree(params);
394 }
395
396 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0045, TestSize.Level0)
397 {
398 // pake_v1_protocol_task_common.c static interface test
399 PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
400 params->pseudonymExtInfo.selfNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
401 EXPECT_NE(params->pseudonymExtInfo.selfNextPseudonymId.val, nullptr);
402 params->pseudonymExtInfo.selfNextPseudonymChallenge.val = (uint8_t *)HcMalloc(16, 0);
403 EXPECT_NE(params->pseudonymExtInfo.selfNextPseudonymChallenge.val, nullptr);
404 params->pseudonymExtInfo.peerNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
405 EXPECT_NE(params->pseudonymExtInfo.peerNextPseudonymId.val, nullptr);
406 int32_t res = SaveNextPseudonymIdAndChallenge(params);
407 EXPECT_NE(res, HC_SUCCESS);
408 DestroyDasPakeV1Params(params);
409 HcFree(params);
410 }
411
412 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest005, TestSize.Level0)
413 {
414 // ipc_adapt.cpp interface test
415 int32_t res = InitIpcCallBackList();
416 ASSERT_EQ(res, HC_SUCCESS);
417 res = InitIpcCallBackList();
418 ASSERT_EQ(res, HC_SUCCESS);
419 DeInitIpcCallBackList();
420 DeInitIpcCallBackList();
421 ResetIpcCallBackNodeByNodeId(-1);
422 ResetIpcCallBackNodeByNodeId(65);
423 ResetIpcCallBackNodeByNodeId(1);
424 res = InitIpcCallBackList();
425 ASSERT_EQ(res, HC_SUCCESS);
426 ResetIpcCallBackNodeByNodeId(1);
427 DeInitIpcCallBackList();
428 AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
429 (void)InitIpcCallBackList();
430 AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
431 DeInitIpcCallBackList();
432 AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
433 (void)InitIpcCallBackList();
434 AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
435 DeInitIpcCallBackList();
436 DelIpcCallBackByAppId(TEST_APP_ID, 0);
437 (void)InitIpcCallBackList();
438 DelIpcCallBackByAppId(TEST_APP_ID, 0);
439 DeInitIpcCallBackList();
440 res = AddReqIdByAppId(TEST_APP_ID, 123);
441 ASSERT_NE(res, HC_SUCCESS);
442 (void)InitIpcCallBackList();
443 res = AddReqIdByAppId(TEST_APP_ID, 123);
444 ASSERT_NE(res, HC_SUCCESS);
445 DeInitIpcCallBackList();
446 AddIpcCbObjByReqId(123, 0, 0);
447 (void)InitIpcCallBackList();
448 AddIpcCbObjByReqId(123, 0, 0);
449 DeInitIpcCallBackList();
450 res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
451 ASSERT_NE(res, HC_SUCCESS);
452 (void)InitIpcCallBackList();
453 res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
454 ASSERT_NE(res, HC_SUCCESS);
455 DeInitIpcCallBackList();
456 DelIpcCallBackByReqId(123, 0, true);
457 DelIpcCallBackByReqId(123, 0, false);
458 }
459
460 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest006, TestSize.Level0)
461 {
462 // ipc_adapt.cpp interface test
463 InitDeviceAuthCbCtx(nullptr, 0);
464 DeviceAuthCallback callback = { 0 };
465 InitDeviceAuthCbCtx(&callback, 1);
466 InitDeviceAuthCbCtx(&callback, 2);
467 InitDevAuthListenerCbCtx(nullptr);
468 DataChangeListener listener = { 0 };
469 InitDevAuthListenerCbCtx(&listener);
470 uintptr_t ptr = 0;
471 int32_t res = CreateServiceInstance(&ptr);
472 ASSERT_EQ(res, HC_SUCCESS);
473 DestroyServiceInstance(ptr);
474 bool isCallback = IsCallbackMethod(0);
475 ASSERT_EQ(isCallback, false);
476 isCallback = IsCallbackMethod(1);
477 ASSERT_EQ(isCallback, true);
478 }
479
480 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest007, TestSize.Level0)
481 {
482 // mk_agree_task.c interface test
483 int32_t res = CreateMkAgreeTask(0, nullptr, nullptr);
484 ASSERT_NE(res, HC_SUCCESS);
485 CJson *in = CreateJson();
486 ASSERT_NE(in, nullptr);
487 res = CreateMkAgreeTask(0, in, nullptr);
488 ASSERT_NE(res, HC_SUCCESS);
489 MkAgreeTaskBase *task = nullptr;
490 res = CreateMkAgreeTask(0, in, &task);
491 ASSERT_NE(res, HC_SUCCESS);
492 (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
493 res = CreateMkAgreeTask(TASK_TYPE_ISO, in, &task);
494 ASSERT_NE(res, HC_SUCCESS);
495 res = CreateMkAgreeTask(2, in, &task);
496 ASSERT_NE(res, HC_SUCCESS);
497 FreeJson(in);
498 }
499
InitCredPlugin(void)500 static int32_t InitCredPlugin(void)
501 {
502 return HC_SUCCESS;
503 }
504
InitCredPluginFail(void)505 static int32_t InitCredPluginFail(void)
506 {
507 return HC_ERROR;
508 }
509
DestroyCredPlugin(void)510 static void DestroyCredPlugin(void) {}
511
ProcessCredTest(int32_t osAccountId,int32_t cmdId,CJson * in,CJson * out)512 static int32_t ProcessCredTest(int32_t osAccountId, int32_t cmdId, CJson *in, CJson *out)
513 {
514 (void)osAccountId;
515 (void)cmdId;
516 (void)in;
517 (void)out;
518 return HC_SUCCESS;
519 }
520
521 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest008, TestSize.Level0)
522 {
523 // ext_plugin_manager.c interface test
524 int32_t res = InitCredMgr();
525 ASSERT_EQ(res, HC_SUCCESS);
526 res = ProcCred(0, DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
527 ASSERT_NE(res, HC_SUCCESS);
528 res = AddCredPlugin(nullptr);
529 ASSERT_NE(res, HC_SUCCESS);
530 CredPlugin plugin = { 0 };
531 res = AddCredPlugin(&plugin);
532 ASSERT_NE(res, HC_SUCCESS);
533 plugin.init = InitCredPlugin;
534 res = AddCredPlugin(&plugin);
535 ASSERT_NE(res, HC_SUCCESS);
536 plugin.destroy = DestroyCredPlugin;
537 res = AddCredPlugin(&plugin);
538 ASSERT_NE(res, HC_SUCCESS);
539 plugin.procCred = ProcessCredTest;
540 res = AddCredPlugin(&plugin);
541 ASSERT_EQ(res, HC_SUCCESS);
542 plugin.init = InitCredPluginFail;
543 res = AddCredPlugin(&plugin);
544 ASSERT_NE(res, HC_SUCCESS);
545 plugin.init = InitCredPlugin;
546 res = AddCredPlugin(&plugin);
547 ASSERT_EQ(res, HC_SUCCESS);
548 DelCredPlugin(0);
549 DestroyCredMgr();
550 }
551
OnChannelOpenedTest(int64_t requestId,int result)552 static int OnChannelOpenedTest(int64_t requestId, int result)
553 {
554 (void)requestId;
555 (void)result;
556 return 0;
557 }
558
OnChannelClosedTest(void)559 static void OnChannelClosedTest(void) {}
560
OnBytesReceivedTest(int64_t requestId,uint8_t * data,uint32_t dataLen)561 static void OnBytesReceivedTest(int64_t requestId, uint8_t *data, uint32_t dataLen)
562 {
563 (void)requestId;
564 (void)data;
565 (void)dataLen;
566 }
567
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)568 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
569 {
570 (void)requestId;
571 (void)data;
572 (void)dataLen;
573 return true;
574 }
575
576 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest009, TestSize.Level0)
577 {
578 // channel_manager.c interface test
579 ChannelProxy proxy = { 0 };
580 proxy.onBytesReceived = OnBytesReceivedTest;
581 proxy.onChannelClosed = OnChannelClosedTest;
582 proxy.onChannelOpened = OnChannelOpenedTest;
583 int32_t res = InitChannelManager(&proxy);
584 ASSERT_NE(res, HC_SUCCESS);
585 DeviceAuthCallback callback = { 0 };
586 CJson *jsonParams = CreateJson();
587 ASSERT_NE(jsonParams, nullptr);
588 ChannelType type = GetChannelType(&callback, jsonParams);
589 ASSERT_EQ(type, NO_CHANNEL);
590 (void)AddStringToJson(jsonParams, FIELD_CONNECT_PARAMS, TEST_CONNECT_PARAMS);
591 type = GetChannelType(&callback, jsonParams);
592 ASSERT_EQ(type, SOFT_BUS);
593 FreeJson(jsonParams);
594 jsonParams = CreateJson();
595 ASSERT_NE(jsonParams, nullptr);
596 callback.onTransmit = OnTransmit;
597 type = GetChannelType(&callback, jsonParams);
598 ASSERT_EQ(type, SERVICE_CHANNEL);
599 FreeJson(jsonParams);
600 res = OpenChannel(SERVICE_CHANNEL, nullptr, 123, nullptr);
601 ASSERT_NE(res, HC_SUCCESS);
602 jsonParams = CreateJson();
603 ASSERT_NE(jsonParams, nullptr);
604 int64_t returnChannelId = 0;
605 res = OpenChannel(SOFT_BUS, jsonParams, 123, &returnChannelId);
606 ASSERT_NE(res, HC_SUCCESS);
607 (void)AddStringToJson(jsonParams, FIELD_CONNECT_PARAMS, TEST_CONNECT_PARAMS);
608 res = OpenChannel(SOFT_BUS, jsonParams, 123, &returnChannelId);
609 ASSERT_NE(res, HC_SUCCESS);
610 FreeJson(jsonParams);
611 res = OpenChannel(NO_CHANNEL, nullptr, 123, &returnChannelId);
612 ASSERT_NE(res, HC_SUCCESS);
613 CloseChannel(SOFT_BUS, 0);
614 res = HcSendMsg(SOFT_BUS, 123, 0, nullptr, TEST_TRANSMIT_DATA);
615 ASSERT_NE(res, HC_SUCCESS);
616 res = HcSendMsg(NO_CHANNEL, 123, 00, nullptr, nullptr);
617 ASSERT_NE(res, HC_SUCCESS);
618 res = HcSendMsg(SERVICE_CHANNEL, 123, 0, nullptr, nullptr);
619 ASSERT_NE(res, HC_SUCCESS);
620 NotifyBindResult(SOFT_BUS, 0);
621 DestroyChannelManager();
622 }
623
InitModuleTest(void)624 static int32_t InitModuleTest(void)
625 {
626 return HC_SUCCESS;
627 }
628
InitModuleFail(void)629 static int32_t InitModuleFail(void)
630 {
631 return HC_ERROR;
632 }
633
DestroyModuleTest(void)634 static void DestroyModuleTest(void) {}
635
CreateTaskTest(int32_t * taskId,const CJson * in,CJson * out)636 static int CreateTaskTest(int32_t *taskId, const CJson *in, CJson *out)
637 {
638 (void)taskId;
639 (void)in;
640 (void)out;
641 return HC_SUCCESS;
642 }
643
ProcessTaskTest(int32_t taskId,const CJson * in,CJson * out,int32_t * status)644 static int ProcessTaskTest(int32_t taskId, const CJson *in, CJson *out, int32_t *status)
645 {
646 (void)taskId;
647 (void)in;
648 (void)out;
649 (void)status;
650 return HC_SUCCESS;
651 }
652
DestroyTaskTest(int taskId)653 static void DestroyTaskTest(int taskId)
654 {
655 (void)taskId;
656 }
657
658 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest010, TestSize.Level0)
659 {
660 // dev_auth_module_manager.c interface test
661 AuthModuleParams params = { DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr, 0 };
662 int32_t res = UnregisterLocalIdentity(¶ms, ACCOUNT_MODULE);
663 ASSERT_NE(res, HC_SUCCESS);
664 InitModules();
665 Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, strlen(TEST_AUTH_ID) };
666 params.authId = &authIdBuff;
667 res = UnregisterLocalIdentity(¶ms, DAS_MODULE);
668 ASSERT_EQ(res, HC_SUCCESS);
669 CJson *in = CreateJson();
670 ASSERT_NE(in, nullptr);
671 res = CheckMsgRepeatability(in, DAS_MODULE);
672 ASSERT_EQ(res, HC_SUCCESS);
673 res = UnregisterLocalIdentity(¶ms, DAS_MODULE);
674 ASSERT_EQ(res, HC_SUCCESS);
675 res = CheckMsgRepeatability(nullptr, DAS_MODULE);
676 ASSERT_NE(res, HC_SUCCESS);
677 res = CheckMsgRepeatability(in, DAS_MODULE);
678 ASSERT_EQ(res, HC_SUCCESS);
679 FreeJson(in);
680 in = CreateJson();
681 ASSERT_NE(in, nullptr);
682 CJson *out = CreateJson();
683 ASSERT_NE(out, nullptr);
684 int32_t taskId = 0;
685 (void)CreateTask(&taskId, in, out, DAS_MODULE);
686 FreeJson(in);
687 FreeJson(out);
688 DestroyTask(0, 0);
689 (void)AddAuthModulePlugin(nullptr);
690 AuthModuleBase plugin = { 0 };
691 (void)AddAuthModulePlugin(&plugin);
692 plugin.init = InitModuleTest;
693 (void)AddAuthModulePlugin(&plugin);
694 plugin.destroy = DestroyModuleTest;
695 (void)AddAuthModulePlugin(&plugin);
696 plugin.createTask = CreateTaskTest;
697 (void)AddAuthModulePlugin(&plugin);
698 plugin.processTask = ProcessTaskTest;
699 (void)AddAuthModulePlugin(&plugin);
700 plugin.destroyTask = DestroyTaskTest;
701 (void)AddAuthModulePlugin(&plugin);
702 plugin.init = InitModuleFail;
703 (void)AddAuthModulePlugin(&plugin);
704 plugin.init = InitModuleTest;
705 res = AddAuthModulePlugin(&plugin);
706 ASSERT_EQ(res, HC_SUCCESS);
707 DelAuthModulePlugin(0);
708 DestroyModules();
709 }
710
711 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest011, TestSize.Level0)
712 {
713 // mbedtls_ec_adapter.c interface test
714 int32_t res = MbedtlsHashToPoint25519(nullptr, nullptr);
715 ASSERT_NE(res, HC_SUCCESS);
716 uint8_t hashVal[64] = { 0 };
717 Uint8Buff hashBuff = { hashVal, 64 };
718 res = MbedtlsHashToPoint25519(&hashBuff, nullptr);
719 ASSERT_NE(res, HC_SUCCESS);
720 uint8_t outEcPointVal[32] = { 0 };
721 Uint8Buff outEcPointBuff = { outEcPointVal, 32 };
722 res = MbedtlsHashToPoint25519(&hashBuff, &outEcPointBuff);
723 ASSERT_NE(res, HC_SUCCESS);
724 uint8_t validHashVal[32] = { 0 };
725 hashBuff.val = validHashVal;
726 hashBuff.length = 32;
727 res = MbedtlsHashToPoint25519(&hashBuff, &outEcPointBuff);
728 ASSERT_EQ(res, HC_SUCCESS);
729 }
730
731 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest012, TestSize.Level0)
732 {
733 // account_task_main.c interface test
734 int32_t taskId = 0;
735 AccountTask *task = CreateAccountTaskT(&taskId, nullptr, nullptr);
736 ASSERT_EQ(task, nullptr);
737 CJson *in = CreateJson();
738 ASSERT_NE(in, nullptr);
739 (void)AddIntToJson(in, FIELD_OPERATION_CODE, MEMBER_JOIN);
740 task = CreateAccountTaskT(&taskId, in, nullptr);
741 ASSERT_EQ(task, nullptr);
742 (void)AddIntToJson(in, FIELD_CREDENTIAL_TYPE, 0);
743 task = CreateAccountTaskT(&taskId, in, nullptr);
744 ASSERT_EQ(task, nullptr);
745 InitVersionInfos();
746 (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
747 (void)AddIntToJson(in, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
748 task = CreateAccountTaskT(&taskId, in, nullptr);
749 ASSERT_EQ(task, nullptr);
750 CJson *out = CreateJson();
751 ASSERT_NE(out, nullptr);
752 (void)AddIntToJson(in, FIELD_IS_CLIENT, true);
753 task = CreateAccountTaskT(&taskId, in, out);
754 ASSERT_EQ(task, nullptr);
755 (void)AddIntToJson(in, FIELD_IS_CLIENT, false);
756 task = CreateAccountTaskT(&taskId, in, out);
757 ASSERT_EQ(task, nullptr);
758 FreeJson(in);
759 FreeJson(out);
760 }
761
762 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest013, TestSize.Level0)
763 {
764 // account_module.c interface test
765 const AuthModuleBase *accountModule = GetAccountModule();
766 ASSERT_NE(accountModule, nullptr);
767 int32_t res = accountModule->init();
768 ASSERT_EQ(res, HC_SUCCESS);
769 bool isIgnored = accountModule->isMsgNeedIgnore(nullptr);
770 ASSERT_EQ(isIgnored, true);
771 CJson *in = CreateJson();
772 ASSERT_NE(in, nullptr);
773 (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
774 isIgnored = accountModule->isMsgNeedIgnore(in);
775 ASSERT_EQ(isIgnored, false);
776 (void)AddIntToJson(in, FIELD_OPERATION_CODE, OP_BIND);
777 isIgnored = accountModule->isMsgNeedIgnore(in);
778 ASSERT_EQ(isIgnored, false);
779 (void)AddIntToJson(in, FIELD_OPERATION_CODE, OP_UNBIND);
780 isIgnored = accountModule->isMsgNeedIgnore(in);
781 ASSERT_EQ(isIgnored, true);
782 (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
783 (void)AddIntToJson(in, FIELD_STEP, 1);
784 isIgnored = accountModule->isMsgNeedIgnore(in);
785 ASSERT_EQ(isIgnored, true);
786 FreeJson(in);
787 res = accountModule->createTask(nullptr, nullptr, nullptr);
788 ASSERT_NE(res, HC_SUCCESS);
789 int32_t taskId = 0;
790 res = accountModule->createTask(&taskId, nullptr, nullptr);
791 ASSERT_NE(res, HC_SUCCESS);
792 in = CreateJson();
793 ASSERT_NE(in, nullptr);
794 res = accountModule->createTask(&taskId, in, nullptr);
795 ASSERT_NE(res, HC_SUCCESS);
796 CJson *out = CreateJson();
797 ASSERT_NE(out, nullptr);
798 res = accountModule->createTask(&taskId, in, out);
799 ASSERT_NE(res, HC_SUCCESS);
800 (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
801 (void)AddIntToJson(in, FIELD_STEP, 0);
802 res = accountModule->createTask(&taskId, in, out);
803 FreeJson(in);
804 FreeJson(out);
805 res = accountModule->processTask(0, nullptr, nullptr, nullptr);
806 accountModule->destroyTask(0);
807 AccountMultiTaskManager *manager = GetAccountMultiTaskManager();
808 (void)manager->addTaskToManager(nullptr);
809 (void)manager->getTaskFromManager(1);
810 accountModule->destroy();
811 }
812
813 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest014, TestSize.Level0)
814 {
815 // identical_account_group.c interface test
816 (void)InitDatabase();
817 (void)InitBroadcastManager();
818 IdenticalAccountGroup *group = (IdenticalAccountGroup *)GetIdenticalAccountGroupInstance();
819 ASSERT_NE(group, nullptr);
820 int32_t res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
821 ASSERT_NE(res, HC_SUCCESS);
822 res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
823 ASSERT_NE(res, HC_SUCCESS);
824 CJson *jsonParams = CreateJson();
825 ASSERT_NE(jsonParams, nullptr);
826 res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, jsonParams);
827 ASSERT_NE(res, HC_SUCCESS);
828 res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
829 ASSERT_NE(res, HC_SUCCESS);
830 res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
831 ASSERT_NE(res, HC_SUCCESS);
832 res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, jsonParams);
833 ASSERT_NE(res, HC_SUCCESS);
834 res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
835 ASSERT_NE(res, HC_SUCCESS);
836 res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, nullptr);
837 ASSERT_NE(res, HC_SUCCESS);
838 char *returnJsonStr = nullptr;
839 res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
840 ASSERT_NE(res, HC_SUCCESS);
841 res = group->base.createGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
842 ASSERT_NE(res, HC_SUCCESS);
843 res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, nullptr);
844 ASSERT_NE(res, HC_SUCCESS);
845 res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
846 ASSERT_NE(res, HC_SUCCESS);
847 (void)AddStringToJson(jsonParams, FIELD_APP_ID, TEST_APP_ID);
848 res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
849 ASSERT_NE(res, HC_SUCCESS);
850 (void)AddStringToJson(jsonParams, FIELD_USER_ID, TEST_GROUP_ID);
851 res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
852 ASSERT_NE(res, HC_SUCCESS);
853 (void)AddStringToJson(jsonParams, FIELD_GROUP_ID, TEST_GROUP_ID);
854 res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
855 ASSERT_EQ(res, HC_SUCCESS);
856 DestroyDatabase();
857 DestroyBroadcastManager();
858 }
859
860 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0141, TestSize.Level0)
861 {
862 // identical_account_group.c static interface test
863 (void)InitDatabase();
864 (void)InitBroadcastManager();
865 int32_t res = GenerateGroupParams(nullptr, nullptr, nullptr);
866 EXPECT_NE(res, HC_SUCCESS);
867 res = GenerateGroupId(nullptr, nullptr);
868 EXPECT_NE(res, HC_SUCCESS);
869 res = GenerateIdenticalGroupId(nullptr, nullptr);
870 EXPECT_NE(res, HC_SUCCESS);
871 CJson *in = CreateJson();
872 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
873 res = GenerateIdenticalGroupId(in, nullptr);
874 EXPECT_NE(res, HC_SUCCESS);
875 FreeJson(in);
876 DestroyDatabase();
877 DestroyBroadcastManager();
878 }
879
880 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0142, TestSize.Level0)
881 {
882 // identical_account_group.c static interface test
883 (void)InitDatabase();
884 (void)InitBroadcastManager();
885 CJson *in = CreateJson();
886 int32_t res = ImportSelfToken(TEST_OS_ACCOUNT_ID, in);
887 EXPECT_NE(res, HC_SUCCESS);
888 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
889 res = ImportSelfToken(TEST_OS_ACCOUNT_ID, in);
890 EXPECT_NE(res, HC_SUCCESS);
891 res = DelSelfToken(TEST_OS_ACCOUNT_ID, nullptr);
892 EXPECT_NE(res, HC_SUCCESS);
893 FreeJson(in);
894 DestroyDatabase();
895 DestroyBroadcastManager();
896 }
897
898 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0143, TestSize.Level0)
899 {
900 // identical_account_group.c static interface test
901 (void)InitDatabase();
902 (void)InitBroadcastManager();
903 CJson *in = CreateJson();
904 int32_t res = GenerateAddTokenParams(in, in);
905 EXPECT_NE(res, HC_SUCCESS);
906 res = CheckUserIdValid(TEST_OS_ACCOUNT_ID, in, in);
907 EXPECT_NE(res, HC_SUCCESS);
908 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
909 res = GenerateAddTokenParams(in, in);
910 EXPECT_NE(res, HC_SUCCESS);
911 res = CheckUserIdValid(TEST_OS_ACCOUNT_ID, in, in);
912 EXPECT_NE(res, HC_SUCCESS);
913 res = GenerateTrustedDevParams(nullptr, nullptr, nullptr);
914 EXPECT_NE(res, HC_SUCCESS);
915 (void)AddStringToJson(in, FIELD_GROUP_ID, TEST_GROUP_ID);
916 res = CheckUserIdValid(TEST_OS_ACCOUNT_ID, in, in);
917 EXPECT_NE(res, HC_SUCCESS);
918
919 FreeJson(in);
920 DestroyDatabase();
921 DestroyBroadcastManager();
922 }
923
924 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0144, TestSize.Level0)
925 {
926 // identical_account_group.c static interface test
927 (void)InitDatabase();
928 (void)InitBroadcastManager();
929 int32_t res = CheckPeerDeviceNotSelf(nullptr);
930 EXPECT_NE(res, HC_SUCCESS);
931 CJson *in = CreateJson();
932 res = AddDeviceAndToken(TEST_OS_ACCOUNT_ID, in, in);
933 EXPECT_NE(res, HC_SUCCESS);
934 res = DelPeerDevice(TEST_OS_ACCOUNT_ID, in, in, true);
935 EXPECT_NE(res, HC_SUCCESS);
936 UpdateTrustedDeviceForMetaNode(TEST_OS_ACCOUNT_ID, nullptr, nullptr);
937
938 (void)AddStringToJson(in, FIELD_GROUP_ID, TEST_GROUP_ID);
939 res = AddDeviceAndToken(TEST_OS_ACCOUNT_ID, in, in);
940 EXPECT_NE(res, HC_SUCCESS);
941 UpdateTrustedDeviceForMetaNode(TEST_OS_ACCOUNT_ID, in, nullptr);
942
943 res = DelPeerDevice(TEST_OS_ACCOUNT_ID, in, in, true);
944 EXPECT_NE(res, HC_SUCCESS);
945 FreeJson(in);
946 DestroyDatabase();
947 DestroyBroadcastManager();
948 }
949
OnGroupCreated(const char * groupInfo)950 static void OnGroupCreated(const char *groupInfo)
951 {
952 (void)groupInfo;
953 }
954
OnGroupDeleted(const char * groupInfo)955 static void OnGroupDeleted(const char *groupInfo)
956 {
957 (void)groupInfo;
958 }
959
OnDeviceBound(const char * peerUdid,const char * groupInfo)960 static void OnDeviceBound(const char *peerUdid, const char *groupInfo)
961 {
962 (void)peerUdid;
963 (void)groupInfo;
964 }
965
OnDeviceUnBound(const char * peerUdid,const char * groupInfo)966 static void OnDeviceUnBound(const char *peerUdid, const char *groupInfo)
967 {
968 (void)peerUdid;
969 (void)groupInfo;
970 }
971
OnDeviceNotTrusted(const char * peerUdid)972 static void OnDeviceNotTrusted(const char *peerUdid)
973 {
974 (void)peerUdid;
975 }
976
OnLastGroupDeleted(const char * peerUdid,int groupType)977 static void OnLastGroupDeleted(const char *peerUdid, int groupType)
978 {
979 (void)peerUdid;
980 (void)groupType;
981 }
982
OnTrustedDeviceNumChanged(int curTrustedDeviceNum)983 static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum)
984 {
985 (void)curTrustedDeviceNum;
986 }
987
988 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest015, TestSize.Level0)
989 {
990 // broadcast_manager.c interface test
991 int32_t res = InitBroadcastManager();
992 ASSERT_EQ(res, HC_SUCCESS);
993 res = AddListener(nullptr, nullptr);
994 ASSERT_NE(res, HC_SUCCESS);
995 res = AddListener(TEST_APP_ID, nullptr);
996 ASSERT_NE(res, HC_SUCCESS);
997 DataChangeListener listener = { 0 };
998 res = AddListener(TEST_APP_ID, &listener);
999 ASSERT_EQ(res, HC_SUCCESS);
1000 res = RemoveListener(nullptr);
1001 ASSERT_NE(res, HC_SUCCESS);
1002 res = RemoveListener(TEST_APP_ID);
1003 ASSERT_EQ(res, HC_SUCCESS);
1004 const Broadcaster *broadcaster = GetBroadcaster();
1005 ASSERT_NE(broadcaster, nullptr);
1006 listener.onDeviceBound = OnDeviceBound;
1007 listener.onDeviceNotTrusted = OnDeviceNotTrusted;
1008 listener.onDeviceUnBound = OnDeviceUnBound;
1009 listener.onGroupCreated = OnGroupCreated;
1010 listener.onGroupDeleted = OnGroupDeleted;
1011 listener.onLastGroupDeleted = OnLastGroupDeleted;
1012 listener.onTrustedDeviceNumChanged = OnTrustedDeviceNumChanged;
1013 res = AddListener(TEST_APP_ID, &listener);
1014 ASSERT_EQ(res, HC_SUCCESS);
1015 broadcaster->postOnTrustedDeviceNumChanged(1);
1016 broadcaster->postOnLastGroupDeleted(nullptr, PEER_TO_PEER_GROUP);
1017 broadcaster->postOnLastGroupDeleted(TEST_AUTH_ID, PEER_TO_PEER_GROUP);
1018 broadcaster->postOnGroupDeleted(nullptr);
1019 broadcaster->postOnGroupDeleted("test");
1020 broadcaster->postOnGroupCreated(nullptr);
1021 broadcaster->postOnGroupCreated("test");
1022 broadcaster->postOnDeviceUnBound(nullptr, nullptr);
1023 broadcaster->postOnDeviceUnBound(TEST_AUTH_ID, nullptr);
1024 broadcaster->postOnDeviceUnBound(TEST_AUTH_ID, "test");
1025 broadcaster->postOnDeviceNotTrusted(nullptr);
1026 broadcaster->postOnDeviceNotTrusted(TEST_AUTH_ID);
1027 broadcaster->postOnDeviceBound(nullptr, nullptr);
1028 broadcaster->postOnDeviceBound(TEST_AUTH_ID, nullptr);
1029 broadcaster->postOnDeviceBound(TEST_AUTH_ID, "test");
1030 res = RemoveListener(TEST_APP_ID);
1031 ASSERT_EQ(res, HC_SUCCESS);
1032 DestroyBroadcastManager();
1033 }
1034
1035 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest016, TestSize.Level0)
1036 {
1037 // iso_protocol_common.c interface test
1038 int res = IsoServerGenSessionKeyAndCalToken(nullptr, nullptr, nullptr);
1039 ASSERT_NE(res, HC_SUCCESS);
1040 IsoBaseParams *baseParams = (IsoBaseParams *)HcMalloc(sizeof(IsoBaseParams), 0);
1041 baseParams->loader = GetLoaderInstance();
1042 res = IsoServerGenSessionKeyAndCalToken(baseParams, nullptr, nullptr);
1043 ASSERT_NE(res, HC_SUCCESS);
1044 Uint8Buff tokenFromPeer = { 0 };
1045 res = IsoServerGenSessionKeyAndCalToken(baseParams, &tokenFromPeer, nullptr);
1046 ASSERT_NE(res, HC_SUCCESS);
1047 Uint8Buff tokenToPeer = { 0 };
1048 res = IsoServerGenSessionKeyAndCalToken(baseParams, &tokenFromPeer, &tokenToPeer);
1049 ASSERT_NE(res, HC_SUCCESS);
1050 res = IsoServerGenRandomAndToken(nullptr, nullptr);
1051 ASSERT_NE(res, HC_SUCCESS);
1052 res = IsoServerGenRandomAndToken(baseParams, nullptr);
1053 ASSERT_NE(res, HC_SUCCESS);
1054 res = IsoClientGenSessionKey(nullptr, 0, nullptr, 0);
1055 ASSERT_NE(res, HC_SUCCESS);
1056 res = IsoClientGenSessionKey(baseParams, 0, nullptr, 0);
1057 ASSERT_NE(res, HC_SUCCESS);
1058 uint8_t hmacVal[256] = { 0 };
1059 res = IsoClientGenSessionKey(baseParams, 0, hmacVal, 256);
1060 ASSERT_NE(res, HC_SUCCESS);
1061 res = IsoClientCheckAndGenToken(nullptr, nullptr, nullptr);
1062 ASSERT_NE(res, HC_SUCCESS);
1063 res = IsoClientCheckAndGenToken(baseParams, nullptr, nullptr);
1064 ASSERT_NE(res, HC_SUCCESS);
1065 Uint8Buff peerToken = { 0 };
1066 res = IsoClientCheckAndGenToken(baseParams, &peerToken, nullptr);
1067 ASSERT_NE(res, HC_SUCCESS);
1068 Uint8Buff selfToken = { 0 };
1069 res = IsoClientCheckAndGenToken(baseParams, &peerToken, &selfToken);
1070 ASSERT_NE(res, HC_SUCCESS);
1071 res = IsoClientGenRandom(nullptr);
1072 ASSERT_NE(res, HC_SUCCESS);
1073 HcFree(baseParams);
1074 }
1075
1076 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0161, TestSize.Level0)
1077 {
1078 // iso_protocol_common.c static interface test
1079 int32_t res = InitIsoBaseParams(nullptr, nullptr);
1080 EXPECT_NE(res, HC_SUCCESS);
1081 CJson *in = CreateJson();
1082 res = InitIsoBaseParams(in, nullptr);
1083 EXPECT_NE(res, HC_SUCCESS);
1084 FreeJson(in);
1085 }
1086
1087 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest017, TestSize.Level0)
1088 {
1089 // das_lite_token_manager.c interface test
1090 const TokenManager *liteManager = GetLiteTokenManagerInstance();
1091 ASSERT_NE(liteManager, nullptr);
1092 Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, strlen(TEST_AUTH_ID) };
1093 TokenManagerParams params = {
1094 .osAccountId = DEFAULT_OS_ACCOUNT,
1095 .pkgName = { (uint8_t *)TEST_APP_ID, HcStrlen(TEST_APP_ID) },
1096 .serviceType = { (uint8_t *)TEST_GROUP_ID, HcStrlen(TEST_GROUP_ID) },
1097 .authId = authIdBuff,
1098 .userType = 0
1099 };
1100 int32_t res = liteManager->unregisterLocalIdentity(¶ms);
1101 ASSERT_EQ(res, HC_SUCCESS);
1102 // das_standard_token_manager.c interface test
1103 const TokenManager *standardMgr = GetStandardTokenManagerInstance();
1104 ASSERT_NE(standardMgr, nullptr);
1105 params.pkgName.val = (uint8_t *)GROUP_MANAGER_PACKAGE_NAME;
1106 params.pkgName.length = HcStrlen(GROUP_MANAGER_PACKAGE_NAME);
1107 res = standardMgr->unregisterLocalIdentity(¶ms);
1108 ASSERT_EQ(res, HC_SUCCESS);
1109 params.pkgName.val = (uint8_t *)TEST_APP_ID;
1110 params.pkgName.length = HcStrlen(TEST_APP_ID);
1111 res = standardMgr->deletePeerAuthInfo(¶ms);
1112 ASSERT_EQ(res, HC_SUCCESS);
1113 PakeParams *pakeParams = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
1114 pakeParams->baseParams.loader = GetLoaderInstance();
1115 char appId[256] = TEST_APP_ID;
1116 char groupId[256] = TEST_GROUP_ID;
1117 pakeParams->packageName = appId;
1118 pakeParams->serviceType = groupId;
1119 pakeParams->baseParams.idSelf.val = (uint8_t *)TEST_AUTH_ID;
1120 pakeParams->baseParams.idSelf.length = strlen(TEST_AUTH_ID);
1121 pakeParams->isSelfFromUpgrade = true;
1122 pakeParams->baseParams.idPeer.val = (uint8_t *)TEST_AUTH_ID;
1123 pakeParams->baseParams.idPeer.length = strlen(TEST_AUTH_ID);
1124 res = standardMgr->computeAndSavePsk(pakeParams);
1125 ASSERT_NE(res, HC_SUCCESS);
1126 Uint8Buff returnPkBuff = { 0 };
1127 res = standardMgr->getPublicKey(¶ms, &returnPkBuff);
1128 ASSERT_NE(res, HC_SUCCESS);
1129 HcFree(pakeParams);
1130 }
1131
1132 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest018, TestSize.Level0)
1133 {
1134 // key_manager.c interface test
1135 int32_t res = GetDevicePubKey(DEFAULT_OS_ACCOUNT, nullptr);
1136 ASSERT_NE(res, HC_SUCCESS);
1137 res = DeletePseudonymPsk(DEFAULT_OS_ACCOUNT, nullptr);
1138 ASSERT_NE(res, HC_SUCCESS);
1139 }
1140
1141 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest019, TestSize.Level0)
1142 {
1143 // group_auth_data_operation.c interface test
1144 (void)InitDatabase();
1145 int32_t authForm = GroupTypeToAuthForm(ACROSS_ACCOUNT_AUTHORIZE_GROUP);
1146 ASSERT_EQ(authForm, AUTH_FORM_ACROSS_ACCOUNT);
1147 authForm = GroupTypeToAuthForm(0);
1148 ASSERT_EQ(authForm, AUTH_FORM_INVALID_TYPE);
1149 int32_t groupType = AuthFormToGroupType(AUTH_FORM_ACCOUNT_UNRELATED);
1150 ASSERT_EQ(groupType, PEER_TO_PEER_GROUP);
1151 groupType = AuthFormToGroupType(AUTH_FORM_ACROSS_ACCOUNT);
1152 ASSERT_EQ(groupType, ACROSS_ACCOUNT_AUTHORIZE_GROUP);
1153 groupType = AuthFormToGroupType(-1);
1154 ASSERT_EQ(groupType, GROUP_TYPE_INVALID);
1155 int32_t res = GaGetTrustedDeviceEntryById(DEFAULT_OS_ACCOUNT, nullptr, true, nullptr, nullptr);
1156 ASSERT_NE(res, HC_SUCCESS);
1157 bool isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
1158 ASSERT_EQ(isAccessiblle, false);
1159 isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, TEST_GROUP_ID, nullptr);
1160 ASSERT_EQ(isAccessiblle, false);
1161 isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, TEST_GROUP_ID, TEST_APP_ID);
1162 ASSERT_EQ(isAccessiblle, false);
1163 DestroyDatabase();
1164 }
1165
1166 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest020, TestSize.Level0)
1167 {
1168 // compatible_bind_sub_session_util.c interface test
1169 InformPeerProcessError(123, nullptr, nullptr, -1);
1170 CJson *jsonParams = CreateJson();
1171 ASSERT_NE(jsonParams, nullptr);
1172 (void)AddStringToJson(jsonParams, FIELD_CHANNEL_ID, "0");
1173 InformPeerProcessError(123, jsonParams, nullptr, -1);
1174 (void)AddStringToJson(jsonParams, FIELD_APP_ID, TEST_APP_ID);
1175 InformPeerProcessError(123, jsonParams, nullptr, -1);
1176 FreeJson(jsonParams);
1177 int32_t res = CombineConfirmData(MEMBER_JOIN, nullptr, nullptr);
1178 ASSERT_NE(res, HC_SUCCESS);
1179 res = CombineConfirmData(MEMBER_INVITE, nullptr, nullptr);
1180 ASSERT_NE(res, HC_SUCCESS);
1181 // compatible_bind_sub_session.c interface test
1182 DestroyCompatibleBindSubSession(nullptr);
1183 res = CreateServerBindSubSession(nullptr, nullptr, nullptr);
1184 ASSERT_NE(res, HC_SUCCESS);
1185 jsonParams = CreateJson();
1186 ASSERT_NE(jsonParams, nullptr);
1187 (void)AddStringToJson(jsonParams, FIELD_REQUEST_ID, "123");
1188 res = CreateServerBindSubSession(jsonParams, nullptr, nullptr);
1189 ASSERT_NE(res, HC_SUCCESS);
1190 (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_INVITE);
1191 res = CreateServerBindSubSession(jsonParams, nullptr, nullptr);
1192 ASSERT_NE(res, HC_SUCCESS);
1193 FreeJson(jsonParams);
1194 res = CreateClientBindSubSession(nullptr, nullptr, nullptr);
1195 ASSERT_NE(res, HC_SUCCESS);
1196 jsonParams = CreateJson();
1197 ASSERT_NE(jsonParams, nullptr);
1198 (void)AddStringToJson(jsonParams, FIELD_REQUEST_ID, "123");
1199 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1200 ASSERT_NE(res, HC_SUCCESS);
1201 (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_INVITE);
1202 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1203 ASSERT_NE(res, HC_SUCCESS);
1204 (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_JOIN);
1205 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1206 ASSERT_NE(res, HC_SUCCESS);
1207 (void)AddIntToJson(jsonParams, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
1208 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1209 ASSERT_NE(res, HC_SUCCESS);
1210 (void)AddIntToJson(jsonParams, FIELD_GROUP_TYPE, PEER_TO_PEER_GROUP);
1211 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1212 ASSERT_NE(res, HC_SUCCESS);
1213 (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_DELETE);
1214 res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1215 ASSERT_NE(res, HC_SUCCESS);
1216 FreeJson(jsonParams);
1217 }
1218
1219 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest021, TestSize.Level0)
1220 {
1221 // compatible_auth_sub_session_common.c interface test
1222 NotifyPeerAuthError(nullptr, nullptr);
1223 int32_t res = HandleAuthTaskStatus(nullptr, nullptr, IGNORE_MSG, true);
1224 ASSERT_EQ(res, HC_SUCCESS);
1225 res = HandleAuthTaskStatus(nullptr, nullptr, CONTINUE, true);
1226 ASSERT_NE(res, HC_SUCCESS);
1227 res = HandleAuthTaskStatus(nullptr, nullptr, 3, true);
1228 ASSERT_NE(res, HC_SUCCESS);
1229 // compatible_auth_sub_session_util.c interface test
1230 int32_t authType = GetAuthType(AUTH_FORM_ACROSS_ACCOUNT);
1231 ASSERT_EQ(authType, ACCOUNT_RELATED_GROUP_AUTH_TYPE);
1232 authType = GetAuthType(AUTH_FORM_INVALID_TYPE);
1233 ASSERT_EQ(authType, INVALID_GROUP_AUTH_TYPE);
1234 CJson *confirmJsonParams = CreateJson();
1235 ASSERT_NE(confirmJsonParams, nullptr);
1236 (void)AddIntToJson(confirmJsonParams, FIELD_OS_ACCOUNT_ID, INVALID_OS_ACCOUNT);
1237 res = CombineAuthConfirmData(confirmJsonParams, nullptr);
1238 ASSERT_NE(res, HC_SUCCESS);
1239 FreeJson(confirmJsonParams);
1240 int32_t moduleType = GetAuthModuleType(nullptr);
1241 ASSERT_EQ(moduleType, INVALID_MODULE_TYPE);
1242 CJson *in = CreateJson();
1243 ASSERT_NE(in, nullptr);
1244 (void)AddIntToJson(in, FIELD_AUTH_FORM, AUTH_FORM_INVALID_TYPE);
1245 moduleType = GetAuthModuleType(in);
1246 ASSERT_EQ(moduleType, INVALID_MODULE_TYPE);
1247 FreeJson(in);
1248 }
1249
1250 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest022, TestSize.Level0)
1251 {
1252 // account_unrelated_group_auth.c interface test
1253 BaseGroupAuth *groupAuth = GetAccountUnrelatedGroupAuth();
1254 ASSERT_NE(groupAuth, nullptr);
1255 groupAuth->onFinish(123, nullptr, nullptr, nullptr);
1256 int32_t res = groupAuth->getAuthParamsVecForServer(nullptr, nullptr);
1257 ASSERT_NE(res, HC_SUCCESS);
1258 }
1259
1260 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest023, TestSize.Level0)
1261 {
1262 // das_task_common.c interface test
1263 int32_t res = GetAndCheckKeyLenOnServer(nullptr, 0);
1264 ASSERT_NE(res, HC_SUCCESS);
1265 CJson *in = CreateJson();
1266 CJson *payload = CreateJson();
1267 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1268 res = GetAndCheckKeyLenOnServer(in, 0);
1269 ASSERT_NE(res, HC_SUCCESS);
1270 (void)AddIntToJson(payload, FIELD_KEY_LENGTH, 1);
1271 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1272 res = GetAndCheckKeyLenOnServer(in, 0);
1273 ASSERT_NE(res, HC_SUCCESS);
1274 FreeJson(payload);
1275 FreeJson(in);
1276 res = GetAuthIdPeerFromPayload(nullptr, nullptr, nullptr);
1277 ASSERT_NE(res, HC_SUCCESS);
1278 in = CreateJson();
1279 payload = CreateJson();
1280 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1281 res = GetAuthIdPeerFromPayload(in, nullptr, nullptr);
1282 ASSERT_NE(res, HC_SUCCESS);
1283 FreeJson(payload);
1284 FreeJson(in);
1285 res = GetAndCheckAuthIdPeer(nullptr, nullptr, nullptr);
1286 ASSERT_NE(res, HC_SUCCESS);
1287 in = CreateJson();
1288 payload = CreateJson();
1289 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1290 res = GetAndCheckAuthIdPeer(in, nullptr, nullptr);
1291 ASSERT_NE(res, HC_SUCCESS);
1292 (void)AddStringToJson(payload, FIELD_PEER_AUTH_ID, "");
1293 (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1294 res = GetAndCheckAuthIdPeer(in, nullptr, nullptr);
1295 ASSERT_NE(res, HC_SUCCESS);
1296 FreeJson(payload);
1297 FreeJson(in);
1298 res = GetIdPeer(nullptr, nullptr, nullptr, nullptr);
1299 ASSERT_NE(res, HC_SUCCESS);
1300 in = CreateJson();
1301 (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, "");
1302 res = GetIdPeer(in, FIELD_PEER_AUTH_ID, nullptr, nullptr);
1303 ASSERT_NE(res, HC_SUCCESS);
1304 FreeJson(in);
1305 res = GeneratePseudonymPskAlias(nullptr, nullptr, nullptr);
1306 ASSERT_NE(res, HC_SUCCESS);
1307 }
1308
1309 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest024, TestSize.Level0)
1310 {
1311 // das_task_common.c interface test
1312 Uint8Buff serviceTypeBuff = { (uint8_t *)TEST_GROUP_ID, 0 };
1313 Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, 0 };
1314 uint8_t outKeyAliasVal[256] = { 0 };
1315 Uint8Buff outKeyAliasBuff = { outKeyAliasVal, 0 };
1316 int32_t res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1317 ASSERT_NE(res, HC_SUCCESS);
1318 serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1319 res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1320 ASSERT_NE(res, HC_SUCCESS);
1321 authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1322 res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1323 ASSERT_NE(res, HC_SUCCESS);
1324 outKeyAliasBuff.length = 256;
1325 serviceTypeBuff.length = SERVICE_TYPE_MAX_LEN + 1;
1326 (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1327 serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1328 authIdBuff.length = AUTH_ID_MAX_LEN + 1;
1329 (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1330 authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1331 (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1332 Uint8Buff pkgNameBuff = { (uint8_t *)TEST_APP_ID, 0 };
1333 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1334 pkgNameBuff.length = HcStrlen(TEST_APP_ID);
1335 serviceTypeBuff.length = 0;
1336 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1337 serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1338 authIdBuff.length = 0;
1339 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1340 authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1341 outKeyAliasBuff.length = 0;
1342 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1343 outKeyAliasBuff.length = 256;
1344 pkgNameBuff.length = PACKAGE_NAME_MAX_LEN + 1;
1345 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1346 pkgNameBuff.length = HcStrlen(TEST_APP_ID);
1347 serviceTypeBuff.length = SERVICE_TYPE_MAX_LEN + 1;
1348 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1349 serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1350 authIdBuff.length = AUTH_ID_MAX_LEN + 1;
1351 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1352 authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1353 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_TYPE_END, &authIdBuff, &outKeyAliasBuff);
1354 (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_PSK, &authIdBuff, &outKeyAliasBuff);
1355 res = GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_AUTH_TOKEN, &authIdBuff, &outKeyAliasBuff);
1356 ASSERT_NE(res, HC_SUCCESS);
1357 }
1358
1359 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest025, TestSize.Level0)
1360 {
1361 // das_version_util.c interface test
1362 VersionStruct version = { 0 };
1363 PakeAlgType type = GetSupportedPakeAlg(&version, PAKE_V2);
1364 type = GetSupportedPakeAlg(&version, ISO);
1365 ProtocolType protocolType = GetPrototolType(&version, CODE_NULL);
1366 ASSERT_EQ(protocolType, PROTOCOL_TYPE_NONE);
1367 version.first = 1;
1368 protocolType = GetPrototolType(&version, AUTHENTICATE);
1369 ASSERT_EQ(protocolType, PROTOCOL_TYPE_NONE);
1370 protocolType = GetPrototolType(&version, OP_BIND);
1371 ASSERT_EQ(protocolType, PAKE_V1);
1372 VersionStruct versionSelf = { 0 };
1373 int32_t res = NegotiateVersion(nullptr, &version, &versionSelf);
1374 ASSERT_EQ(res, HC_SUCCESS);
1375 version.first = 0;
1376 res = NegotiateVersion(nullptr, &version, &versionSelf);
1377 ASSERT_NE(res, HC_SUCCESS);
1378 res = GetSingleVersionFromJson(nullptr, nullptr);
1379 ASSERT_NE(res, HC_SUCCESS);
1380 CJson *jsonObj = CreateJson();
1381 res = GetSingleVersionFromJson(jsonObj, nullptr);
1382 ASSERT_NE(res, HC_SUCCESS);
1383 res = GetSingleVersionFromJson(jsonObj, &version);
1384 ASSERT_NE(res, HC_SUCCESS);
1385 (void)AddStringToJson(jsonObj, FIELD_GROUP_AND_MODULE_VERSION, "123");
1386 res = GetSingleVersionFromJson(jsonObj, &version);
1387 ASSERT_EQ(res, HC_SUCCESS);
1388 (void)AddStringToJson(jsonObj, FIELD_GROUP_AND_MODULE_VERSION, "1.2.3");
1389 res = GetSingleVersionFromJson(jsonObj, &version);
1390 ASSERT_EQ(res, HC_SUCCESS);
1391 }
1392
1393 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest026, TestSize.Level0)
1394 {
1395 // pake_v1_protocol_common.c interface test
1396 DestroyPakeV1BaseParams(nullptr);
1397 int32_t res = InitPakeV1BaseParams(DEFAULT_OS_ACCOUNT, nullptr);
1398 ASSERT_NE(res, HC_SUCCESS);
1399 res = ClientConfirmPakeV1Protocol(nullptr);
1400 ASSERT_NE(res, HC_SUCCESS);
1401 PakeBaseParams *params = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
1402 params->loader = GetLoaderInstance();
1403 res = ClientConfirmPakeV1Protocol(params);
1404 ASSERT_NE(res, HC_SUCCESS);
1405 res = ClientVerifyConfirmPakeV1Protocol(nullptr);
1406 ASSERT_NE(res, HC_SUCCESS);
1407 res = ClientVerifyConfirmPakeV1Protocol(params);
1408 ASSERT_NE(res, HC_SUCCESS);
1409 res = ServerResponsePakeV1Protocol(nullptr);
1410 ASSERT_NE(res, HC_SUCCESS);
1411 res = ServerResponsePakeV1Protocol(params);
1412 ASSERT_NE(res, HC_SUCCESS);
1413 res = ServerConfirmPakeV1Protocol(nullptr);
1414 ASSERT_NE(res, HC_SUCCESS);
1415 res = ServerConfirmPakeV1Protocol(params);
1416 ASSERT_NE(res, HC_SUCCESS);
1417 HcFree(params);
1418 }
1419
1420 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest027, TestSize.Level0)
1421 {
1422 // huks_adapter.c interface test
1423 const AlgLoader *loader = GetLoaderInstance();
1424 ASSERT_NE(loader, nullptr);
1425 int32_t res = loader->importSymmetricKey(nullptr, nullptr, KEY_PURPOSE_SIGN_VERIFY, nullptr);
1426 ASSERT_NE(res, HC_SUCCESS);
1427 bool ret = loader->checkDlPublicKey(nullptr, nullptr);
1428 ASSERT_EQ(ret, false);
1429 Uint8Buff key = { 0 };
1430 ret = loader->checkDlPublicKey(&key, nullptr);
1431 ASSERT_EQ(ret, false);
1432 uint8_t keyVal[256] = { 0 };
1433 key.val = keyVal;
1434 key.length = 256;
1435 ret = loader->checkDlPublicKey(&key, nullptr);
1436 ASSERT_EQ(ret, false);
1437 ret = loader->checkDlPublicKey(&key, "TestPrimeHex");
1438 ASSERT_EQ(ret, false);
1439 res = loader->bigNumCompare(nullptr, nullptr);
1440 ASSERT_EQ(res, HC_SUCCESS);
1441 Uint8Buff aBuff = { 0 };
1442 Uint8Buff bBuff = { 0 };
1443 res = loader->bigNumCompare(&aBuff, &bBuff);
1444 ASSERT_EQ(res, HC_SUCCESS);
1445 res = loader->sign(nullptr, nullptr, ED25519, nullptr);
1446 ASSERT_NE(res, HC_SUCCESS);
1447 res = loader->generateKeyPair(ED25519, nullptr, nullptr);
1448 ASSERT_NE(res, HC_SUCCESS);
1449 Uint8Buff outPrivKey = { 0 };
1450 res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1451 ASSERT_NE(res, HC_SUCCESS);
1452 uint8_t outPrivKeyVal[256] = { 0 };
1453 outPrivKey.val = outPrivKeyVal;
1454 res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1455 ASSERT_NE(res, HC_SUCCESS);
1456 outPrivKey.length = 256;
1457 res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1458 ASSERT_NE(res, HC_SUCCESS);
1459 Uint8Buff outPubKey = { 0 };
1460 res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1461 ASSERT_NE(res, HC_SUCCESS);
1462 uint8_t outPubKeyVal[256] = { 0 };
1463 outPubKey.val = outPubKeyVal;
1464 res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1465 ASSERT_NE(res, HC_SUCCESS);
1466 outPubKey.length = 128;
1467 res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1468 ASSERT_NE(res, HC_SUCCESS);
1469 }
1470
1471 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest028, TestSize.Level0)
1472 {
1473 // dev_session_util.c interface test
1474 int32_t res = AddPkInfoWithPdid(nullptr, nullptr, false, nullptr);
1475 ASSERT_NE(res, HC_SUCCESS);
1476 CJson *context = CreateJson();
1477 res = AddPkInfoWithPdid(context, nullptr, false, nullptr);
1478 ASSERT_NE(res, HC_SUCCESS);
1479 CJson *credJson = CreateJson();
1480 res = AddPkInfoWithPdid(context, credJson, false, nullptr);
1481 ASSERT_NE(res, HC_SUCCESS);
1482 res = AddPkInfoWithPdid(context, credJson, false, "TestRealPkInfo");
1483 ASSERT_NE(res, HC_SUCCESS);
1484 CJson *realPkInfoJson = CreateJson();
1485 (void)AddStringToJson(realPkInfoJson, FIELD_USER_ID, TEST_GROUP_ID);
1486 (void)AddStringToJson(realPkInfoJson, FIELD_DEVICE_ID, TEST_AUTH_ID);
1487 char *realPkInfoStr = PackJsonToString(realPkInfoJson);
1488 FreeJson(realPkInfoJson);
1489 res = AddPkInfoWithPdid(context, credJson, false, realPkInfoStr);
1490 FreeJsonString(realPkInfoStr);
1491 ASSERT_NE(res, HC_SUCCESS);
1492 FreeJson(context);
1493 FreeJson(credJson);
1494 res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, nullptr, nullptr, nullptr);
1495 ASSERT_NE(res, HC_SUCCESS);
1496 credJson = CreateJson();
1497 (void)AddStringToJson(credJson, FIELD_PK_INFO, "TestPkInfo");
1498 res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, credJson, nullptr, nullptr);
1499 ASSERT_NE(res, HC_SUCCESS);
1500 CJson *pkInfoJson = CreateJson();
1501 (void)AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_GROUP_ID);
1502 (void)AddStringToJson(pkInfoJson, FIELD_DEVICE_ID, TEST_AUTH_ID);
1503 char *pkInfoStr = PackJsonToString(pkInfoJson);
1504 FreeJson(pkInfoJson);
1505 (void)AddStringToJson(credJson, FIELD_PK_INFO, pkInfoStr);
1506 FreeJsonString(pkInfoStr);
1507 res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, credJson, nullptr, nullptr);
1508 ASSERT_NE(res, HC_SUCCESS);
1509 FreeJson(credJson);
1510 }
1511
1512 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0281, TestSize.Level0)
1513 {
1514 // dev_session_util.c static interface test
1515 CJson *in = CreateJson();
1516 TrustedDeviceEntry *entry = GetPeerDeviceEntryByContext(TEST_OS_ACCOUNT_ID, in);
1517 EXPECT_EQ(entry, nullptr);
1518 (void)AddStringToJson(in, FIELD_GROUP_ID, TEST_GROUP_ID);
1519 entry = GetPeerDeviceEntryByContext(TEST_OS_ACCOUNT_ID, in);
1520 EXPECT_EQ(entry, nullptr);
1521 (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, TEST_AUTH_ID);
1522 entry = GetPeerDeviceEntryByContext(TEST_OS_ACCOUNT_ID, in);
1523 EXPECT_EQ(entry, nullptr);
1524 FreeJson(in);
1525 }
1526
1527 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0282, TestSize.Level0)
1528 {
1529 // dev_session_util.c static interface test
1530 CJson *in = CreateJson();
1531 int32_t res = SetPeerAuthIdByDb(in, TEST_GROUP_ID);
1532 EXPECT_NE(res, HC_SUCCESS);
1533 (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
1534 res = SetPeerAuthIdByDb(in, TEST_GROUP_ID);
1535 EXPECT_NE(res, HC_SUCCESS);
1536 (void)AddStringToJson(in, FIELD_PEER_UDID, TEST_AUTH_ID);
1537 res = SetPeerAuthIdByDb(in, TEST_GROUP_ID);
1538 EXPECT_NE(res, HC_SUCCESS);
1539
1540 FreeJson(in);
1541 }
1542
1543 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0283, TestSize.Level0)
1544 {
1545 // dev_session_util.c static interface test
1546 CJson *in = CreateJson();
1547 CJson *inputData = CreateJson();
1548 (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, TEST_AUTH_ID);
1549 int32_t res = FillPeerAuthIdIfNeeded(true, in, inputData);
1550 EXPECT_NE(res, HC_SUCCESS);
1551 FreeJson(in);
1552 FreeJson(inputData);
1553 }
1554
1555 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0284, TestSize.Level0)
1556 {
1557 // dev_session_util.c static interface test
1558 int32_t res = BuildPeerCertInfo(nullptr, nullptr, 0, nullptr);
1559 EXPECT_NE(res, HC_SUCCESS);
1560 res = BuildPeerCertInfo(TEST_PK_INFO, nullptr, 0, nullptr);
1561 EXPECT_NE(res, HC_SUCCESS);
1562 res = BuildPeerCertInfo(TEST_PK_INFO, TEST_PK_INFO_SIGN, 0, nullptr);
1563 EXPECT_NE(res, HC_SUCCESS);
1564 }
1565
1566 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0285, TestSize.Level0)
1567 {
1568 // dev_session_util.c static interface test
1569 CJson *in = CreateJson();
1570 int32_t res = GetPeerCertInfo(nullptr, nullptr, nullptr);
1571 EXPECT_NE(res, HC_SUCCESS);
1572 res = GetPeerCertInfo(in, nullptr, nullptr);
1573 EXPECT_NE(res, HC_SUCCESS);
1574 res = GetPeerCertInfo(in, in, nullptr);
1575 EXPECT_NE(res, HC_SUCCESS);
1576 (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, TEST_OS_ACCOUNT_ID);
1577 CertInfo certInfo = { { nullptr, 0 }, { nullptr, 0 }, P256 };
1578 res = GetPeerCertInfo(in, in, &certInfo);
1579 EXPECT_NE(res, HC_SUCCESS);
1580 FreeJson(in);
1581 }
1582
1583 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0286, TestSize.Level0)
1584 {
1585 // dev_session_util.c static interface test
1586 CJson *in = CreateJson();
1587 int32_t res = AddMsgToSessionMsg(0, nullptr, nullptr);
1588 EXPECT_NE(res, HC_SUCCESS);
1589 res = AddMsgToSessionMsg(0, in, nullptr);
1590 EXPECT_NE(res, HC_SUCCESS);
1591 FreeJson(in);
1592 }
1593
1594 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0287, TestSize.Level0)
1595 {
1596 // dev_session_util.c static interface test
1597 int32_t res = IsPeerSameUserId(TEST_OS_ACCOUNT_ID, nullptr);
1598 EXPECT_NE(res, HC_SUCCESS);
1599
1600 res = GeneratePeerInfoJson(nullptr, nullptr);
1601 EXPECT_NE(res, HC_SUCCESS);
1602 CJson *in = CreateJson();
1603 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
1604 res = GeneratePeerInfoJson(in, nullptr);
1605 EXPECT_NE(res, HC_SUCCESS);
1606
1607 res = SetPeerAuthIdByCredAuthInfo(nullptr);
1608 EXPECT_NE(res, HC_SUCCESS);
1609 CJson *credDataJson = CreateJsonFromString(CRED_DATA);
1610 (void)AddObjToJson(in, FIELD_CREDENTIAL_OBJ, credDataJson);
1611 FreeJson(credDataJson);
1612 res = SetPeerAuthIdByCredAuthInfo(in);
1613 EXPECT_NE(res, HC_SUCCESS);
1614 FreeJson(in);
1615 }
1616
1617 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0288, TestSize.Level0)
1618 {
1619 // dev_session_util.c static interface test
1620 CJson *in = CreateJson();
1621 int32_t res = GetPdidIndexByISInfo(in, nullptr);
1622 EXPECT_NE(res, HC_SUCCESS);
1623 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
1624 res = GetPdidIndexByISInfo(in, nullptr);
1625 EXPECT_NE(res, HC_SUCCESS);
1626 FreeJson(in);
1627 }
1628
1629 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest0289, TestSize.Level0)
1630 {
1631 // dev_session_util.c static interface test
1632 CJson *in = CreateJson();
1633 int32_t res = BuildRealPkInfoJson(nullptr, nullptr, nullptr);
1634 EXPECT_NE(res, HC_SUCCESS);
1635 (void)AddStringToJson(in, FIELD_DEVICE_PK, TEST_DEVICE_PK);
1636 res = BuildRealPkInfoJson(in, nullptr, nullptr);
1637 EXPECT_NE(res, HC_SUCCESS);
1638 (void)AddStringToJson(in, FIELD_VERSION, TEST_VERSION);
1639 res = BuildRealPkInfoJson(in, nullptr, nullptr);
1640 EXPECT_NE(res, HC_SUCCESS);
1641 (void)AddStringToJson(in, FIELD_USER_ID, TEST_USER_ID);
1642 res = BuildRealPkInfoJson(in, in, nullptr);
1643 EXPECT_NE(res, HC_SUCCESS);
1644 (void)AddStringToJson(in, FIELD_DEVICE_ID, TEST_DEVICE_ID);
1645 res = BuildRealPkInfoJson(in, in, nullptr);
1646 EXPECT_NE(res, HC_SUCCESS);
1647 FreeJson(in);
1648 }
1649
1650 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest029, TestSize.Level0)
1651 {
1652 // pake_v2_protocol_common.c interface test
1653 DestroyPakeV2BaseParams(nullptr);
1654 int32_t res = ServerConfirmPakeV2Protocol(nullptr);
1655 ASSERT_NE(res, HC_SUCCESS);
1656 PakeBaseParams *params = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
1657 params->loader = GetLoaderInstance();
1658 res = ServerConfirmPakeV2Protocol(params);
1659 ASSERT_NE(res, HC_SUCCESS);
1660 res = ServerResponsePakeV2Protocol(nullptr);
1661 ASSERT_NE(res, HC_SUCCESS);
1662 res = ServerResponsePakeV2Protocol(params);
1663 ASSERT_NE(res, HC_SUCCESS);
1664 res = ClientVerifyConfirmPakeV2Protocol(nullptr);
1665 ASSERT_NE(res, HC_SUCCESS);
1666 res = ClientVerifyConfirmPakeV2Protocol(params);
1667 ASSERT_NE(res, HC_SUCCESS);
1668 res = ClientConfirmPakeV2Protocol(nullptr);
1669 ASSERT_NE(res, HC_SUCCESS);
1670 res = ClientConfirmPakeV2Protocol(params);
1671 ASSERT_NE(res, HC_SUCCESS);
1672 res = InitPakeV2BaseParams(DEFAULT_OS_ACCOUNT, nullptr);
1673 ASSERT_NE(res, HC_SUCCESS);
1674 HcFree(params);
1675 }
1676
1677 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest030, TestSize.Level0)
1678 {
1679 // iso_task_common.c interface test
1680 IsoParams *params = (IsoParams *)HcMalloc(sizeof(IsoParams), 0);
1681 int res = GeneratePsk(nullptr, params);
1682 ASSERT_NE(res, HC_SUCCESS);
1683 res = GenerateKeyAliasInIso(nullptr, nullptr, 0, false);
1684 ASSERT_NE(res, HC_SUCCESS);
1685 res = GenerateKeyAliasInIso(params, nullptr, 0, false);
1686 ASSERT_NE(res, HC_SUCCESS);
1687 uint8_t keyAliasVal[256] = { 0 };
1688 res = GenerateKeyAliasInIso(params, keyAliasVal, 0, false);
1689 ASSERT_NE(res, HC_SUCCESS);
1690 params->packageName = (char *)HcMalloc(HcStrlen(TEST_APP_ID) + 1, 0);
1691 (void)memcpy_s(params->packageName, HcStrlen(TEST_APP_ID) + 1, TEST_APP_ID, HcStrlen(TEST_APP_ID));
1692 params->serviceType = (char *)HcMalloc(HcStrlen(TEST_GROUP_ID) + 1, 0);
1693 (void)memcpy_s(params->serviceType, HcStrlen(TEST_GROUP_ID) + 1, TEST_GROUP_ID, HcStrlen(TEST_GROUP_ID));
1694 res = GenerateKeyAliasInIso(params, keyAliasVal, 256, false);
1695 ASSERT_NE(res, HC_SUCCESS);
1696 res = InitIsoParams(params, nullptr);
1697 ASSERT_NE(res, HC_SUCCESS);
1698 CJson *in = CreateJson();
1699 (void)AddIntToJson(in, FIELD_OPERATION_CODE, CODE_NULL);
1700 res = InitIsoParams(params, in);
1701 ASSERT_NE(res, HC_SUCCESS);
1702 (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
1703 res = InitIsoParams(params, in);
1704 ASSERT_NE(res, HC_SUCCESS);
1705 (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
1706 res = InitIsoParams(params, in);
1707 ASSERT_NE(res, HC_SUCCESS);
1708 DestroyIsoParams(nullptr);
1709 HcFree(params);
1710 }
1711
1712 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest031, TestSize.Level0)
1713 {
1714 // das_task_common.c interface test
1715 int res = ServerProtocolMessageOut(nullptr, 0, 0);
1716 ASSERT_EQ(res, HC_SUCCESS);
1717 CJson *out = CreateJson();
1718 CJson *sendToPeer = CreateJson();
1719 (void)AddObjToJson(out, FIELD_SEND_TO_PEER, sendToPeer);
1720 res = ServerProtocolMessageOut(out, CODE_NULL, 0);
1721 ASSERT_NE(res, HC_SUCCESS);
1722 res = ClientProtocolMessageOut(nullptr, 0, 0);
1723 ASSERT_EQ(res, HC_SUCCESS);
1724 res = ClientProtocolMessageOut(out, CODE_NULL, 0);
1725 ASSERT_NE(res, HC_SUCCESS);
1726 FreeJson(sendToPeer);
1727 FreeJson(out);
1728 CJson *in = CreateJson();
1729 (void)AddIntToJson(in, FIELD_MESSAGE, ERR_MESSAGE);
1730 uint32_t msg = ProtocolMessageIn(in);
1731 ASSERT_EQ(msg, ERR_MESSAGE);
1732 FreeJson(in);
1733 }
1734
1735 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest032, TestSize.Level0)
1736 {
1737 // dev_session_util.c interface test
1738 int32_t res = CheckPeerPkInfoForPdid(nullptr, nullptr);
1739 ASSERT_NE(res, HC_SUCCESS);
1740 CJson *context = CreateJson();
1741 (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1742 res = CheckPeerPkInfoForPdid(context, nullptr);
1743 ASSERT_NE(res, HC_SUCCESS);
1744 CJson *inputDataJson = CreateJson();
1745 (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, "TestPkInfo");
1746 res = CheckPeerPkInfoForPdid(context, inputDataJson);
1747 ASSERT_NE(res, HC_SUCCESS);
1748 CJson *pkInfoJson = CreateJson();
1749 (void)AddStringToJson(pkInfoJson, FIELD_PSEUDONYM_ID, "TestPseudonymId");
1750 char *pkInfoStr = PackJsonToString(pkInfoJson);
1751 FreeJson(pkInfoJson);
1752 (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, pkInfoStr);
1753 FreeJsonString(pkInfoStr);
1754 res = CheckPeerPkInfoForPdid(context, inputDataJson);
1755 ASSERT_EQ(res, HC_SUCCESS);
1756 FreeJson(context);
1757 FreeJson(inputDataJson);
1758 res = SetPeerInfoToContext(nullptr, false, nullptr);
1759 ASSERT_NE(res, HC_SUCCESS);
1760 inputDataJson = CreateJson();
1761 (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, "TestPkInfo");
1762 res = SetPeerInfoToContext(nullptr, false, inputDataJson);
1763 ASSERT_NE(res, HC_SUCCESS);
1764 pkInfoJson = CreateJson();
1765 pkInfoStr = PackJsonToString(pkInfoJson);
1766 FreeJson(pkInfoJson);
1767 (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, pkInfoStr);
1768 FreeJsonString(pkInfoStr);
1769 res = SetPeerInfoToContext(nullptr, false, inputDataJson);
1770 ASSERT_NE(res, HC_SUCCESS);
1771 FreeJson(inputDataJson);
1772 }
1773
1774 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest033, TestSize.Level0)
1775 {
1776 // huks_adapter.c interface test
1777 const AlgLoader *loader = GetLoaderInstance();
1778 ASSERT_NE(loader, nullptr);
1779 int32_t res = loader->agreeSharedSecretWithStorage(nullptr, nullptr, X25519, 0, nullptr);
1780 ASSERT_NE(res, HC_SUCCESS);
1781 res = loader->getKeyExtInfo(nullptr, nullptr);
1782 ASSERT_NE(res, HC_SUCCESS);
1783 KeyParams keyParams = { { nullptr, 0, true }, true, DEFAULT_OS_ACCOUNT };
1784 res = loader->getKeyExtInfo(&keyParams, nullptr);
1785 uint8_t keyAliasVal[256] = { 0 };
1786 keyParams.keyBuff.key = keyAliasVal;
1787 keyParams.keyBuff.keyLen = 256;
1788 res = loader->getKeyExtInfo(&keyParams, nullptr);
1789 ASSERT_NE(res, HC_SUCCESS);
1790 Uint8Buff outExtInfo = { 0 };
1791 res = loader->getKeyExtInfo(&keyParams, &outExtInfo);
1792 ASSERT_NE(res, HC_SUCCESS);
1793 keyParams.isDeStorage = false;
1794 res = loader->getKeyExtInfo(&keyParams, &outExtInfo);
1795 ASSERT_NE(res, HC_SUCCESS);
1796 res = loader->computePseudonymPsk(nullptr, nullptr, nullptr, nullptr);
1797 ASSERT_NE(res, HC_SUCCESS);
1798 KeyParams params = { { 0 }, false, DEFAULT_OS_ACCOUNT };
1799 uint8_t keyValue[256] = { 0 };
1800 params.keyBuff.key = keyValue;
1801 params.keyBuff.keyLen = 256;
1802 params.keyBuff.isAlias = true;
1803 params.isDeStorage = true;
1804 res = loader->computePseudonymPsk(¶ms, nullptr, nullptr, nullptr);
1805 ASSERT_NE(res, HC_SUCCESS);
1806 uint8_t pskAliasVal[256] = { 0 };
1807 Uint8Buff pskAlias = { pskAliasVal, 256 };
1808 uint8_t outPskVal[32] = { 0 };
1809 Uint8Buff outPsk = { outPskVal, 32 };
1810 res = loader->computePseudonymPsk(¶ms, &pskAlias, nullptr, &outPsk);
1811 ASSERT_NE(res, HC_SUCCESS);
1812 Uint8Buff extInfo = { 0 };
1813 res = loader->computePseudonymPsk(¶ms, &pskAlias, &extInfo, &outPsk);
1814 ASSERT_NE(res, HC_SUCCESS);
1815 res = loader->computeHkdf(nullptr, nullptr, nullptr, nullptr);
1816 ASSERT_NE(res, HC_SUCCESS);
1817 res = loader->computeHmacWithThreeStage(nullptr, nullptr, nullptr);
1818 ASSERT_NE(res, HC_SUCCESS);
1819 }
1820
1821 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest034, TestSize.Level0)
1822 {
1823 // account_task_manager.c interface test
1824 DestroyAccountTaskManager();
1825 bool hasAccountPlugin = HasAccountPlugin();
1826 ASSERT_EQ(hasAccountPlugin, false);
1827 int32_t res = ExecuteAccountAuthCmd(DEFAULT_OS_ACCOUNT, IMPORT_SELF_CREDENTIAL, nullptr, nullptr);
1828 ASSERT_NE(res, HC_SUCCESS);
1829 int32_t sessionId = 0;
1830 res = CreateAccountAuthSession(&sessionId, nullptr, nullptr);
1831 ASSERT_NE(res, HC_SUCCESS);
1832 res = ProcessAccountAuthSession(&sessionId, nullptr, nullptr, nullptr);
1833 ASSERT_NE(res, HC_SUCCESS);
1834 res = DestroyAccountAuthSession(sessionId);
1835 ASSERT_NE(res, HC_SUCCESS);
1836 res = LoadAccountAndAddTaskRecord(0);
1837 ASSERT_NE(res, HC_SUCCESS);
1838 RemoveAccountTaskRecordAndUnload(0);
1839 NotifyAsyncTaskStart();
1840 NotifyAsyncTaskStop();
1841 res = InitAccountTaskManager();
1842 ASSERT_EQ(res, HC_SUCCESS);
1843 res = InitAccountTaskManager();
1844 ASSERT_EQ(res, HC_SUCCESS);
1845 res = ExecuteAccountAuthCmd(DEFAULT_OS_ACCOUNT, IMPORT_SELF_CREDENTIAL, nullptr, nullptr);
1846 ASSERT_NE(res, HC_SUCCESS);
1847 res = CreateAccountAuthSession(&sessionId, nullptr, nullptr);
1848 ASSERT_NE(res, HC_SUCCESS);
1849 res = ProcessAccountAuthSession(&sessionId, nullptr, nullptr, nullptr);
1850 ASSERT_NE(res, HC_SUCCESS);
1851 res = DestroyAccountAuthSession(sessionId);
1852 ASSERT_NE(res, HC_SUCCESS);
1853 res = LoadAccountAndAddTaskRecord(0);
1854 ASSERT_EQ(res, HC_SUCCESS);
1855 RemoveAccountTaskRecordAndUnload(0);
1856 NotifyAsyncTaskStart();
1857 NotifyAsyncTaskStart();
1858 NotifyAsyncTaskStop();
1859 NotifyAsyncTaskStop();
1860 DestroyAccountTaskManager();
1861 }
1862
1863 class AvInterfaceTest : public testing::Test {
1864 public:
1865 static void SetUpTestCase();
1866 static void TearDownTestCase();
1867 void SetUp();
1868 void TearDown();
1869 };
1870
SetUpTestCase()1871 void AvInterfaceTest::SetUpTestCase() {}
TearDownTestCase()1872 void AvInterfaceTest::TearDownTestCase() {}
1873
SetUp()1874 void AvInterfaceTest::SetUp()
1875 {
1876 int ret = InitDeviceAuthService();
1877 EXPECT_EQ(ret, HC_SUCCESS);
1878 }
1879
TearDown()1880 void AvInterfaceTest::TearDown()
1881 {
1882 DestroyDeviceAuthService();
1883 }
1884
1885 HWTEST_F(AvInterfaceTest, AvInterfaceTest001, TestSize.Level0)
1886 {
1887 const AccountVerifier *verifier = GetAccountVerifierInstance();
1888 ASSERT_NE(verifier, nullptr);
1889 int32_t res = verifier->getClientSharedKey(nullptr, nullptr, nullptr, nullptr);
1890 ASSERT_NE(res, HC_SUCCESS);
1891 res = verifier->getClientSharedKey(TEST_SERVER_PK, nullptr, nullptr, nullptr);
1892 ASSERT_NE(res, HC_SUCCESS);
1893 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, nullptr, nullptr);
1894 ASSERT_NE(res, HC_SUCCESS);
1895 DataBuff sharedKeyBuff = { nullptr, 0 };
1896 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, &sharedKeyBuff, nullptr);
1897 ASSERT_NE(res, HC_SUCCESS);
1898 DataBuff randomBuff = { nullptr, 0 };
1899 res = verifier->getClientSharedKey(TEST_SERVER_PK, TEST_APP_ID, &sharedKeyBuff, &randomBuff);
1900 ASSERT_NE(res, HC_SUCCESS);
1901 res = verifier->getServerSharedKey(nullptr, nullptr, nullptr, nullptr);
1902 ASSERT_NE(res, HC_SUCCESS);
1903 res = verifier->getServerSharedKey(TEST_CLIENT_PK, nullptr, nullptr, nullptr);
1904 ASSERT_NE(res, HC_SUCCESS);
1905 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, nullptr, nullptr);
1906 ASSERT_NE(res, HC_SUCCESS);
1907 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, nullptr);
1908 ASSERT_NE(res, HC_SUCCESS);
1909 uint8_t randomVal[TEST_RANDOM_LEN] = { 0 };
1910 randomBuff.data = randomVal;
1911 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, nullptr);
1912 ASSERT_NE(res, HC_SUCCESS);
1913 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, &sharedKeyBuff);
1914 ASSERT_NE(res, HC_SUCCESS);
1915 randomBuff.length = TEST_RANDOM_LEN;
1916 res = verifier->getServerSharedKey(TEST_CLIENT_PK, TEST_APP_ID, &randomBuff, &sharedKeyBuff);
1917 ASSERT_NE(res, HC_SUCCESS);
1918 verifier->destroyDataBuff(nullptr);
1919 verifier->destroyDataBuff(&sharedKeyBuff);
1920 }
1921 } // namespace