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