1 /*
2  * Copyright (C) 2024 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 "cred_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 "identical_account_group.h"
40 #include "broadcast_manager.h"
41 #include "iso_protocol_common.h"
42 #include "das_lite_token_manager.h"
43 #include "das_standard_token_manager.h"
44 #include "key_manager.h"
45 #include "group_auth_data_operation.h"
46 #include "compatible_bind_sub_session_util.h"
47 #include "compatible_bind_sub_session.h"
48 #include "compatible_auth_sub_session_common.h"
49 #include "compatible_auth_sub_session_util.h"
50 #include "account_unrelated_group_auth.h"
51 #include "das_task_common.h"
52 #include "das_version_util.h"
53 #include "pake_v1_protocol_common.h"
54 #include "dev_session_util.h"
55 #include "pake_v2_protocol_common.h"
56 #include "iso_task_common.h"
57 
58 using namespace std;
59 using namespace testing::ext;
60 
61 namespace {
62 #define TEST_PSEUDONYM_ID "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
63 #define TEST_PSEUDONYM_CHALLENGE "5420459D93FE773F9945FD64277FBA2CAB8FB996DDC1D0B97676FBB1242B3930"
64 #define TEST_CONNECT_PARAMS "TestConnectParams"
65 #define TEST_TRANSMIT_DATA "TestTransmitData"
66 #define TEST_APP_ID "TestAppId"
67 #define TEST_GROUP_ID "E2EE6F830B176B2C96A9F99BFAE2A61F5D1490B9F4A090E9D8C2874C230C7C21"
68 #define TEST_AUTH_ID "TestAuthId"
69 
70 class DeviceAuthInterfaceTest : public testing::Test {
71 public:
72     static void SetUpTestCase();
73     static void TearDownTestCase();
74     void SetUp();
75     void TearDown();
76 };
77 
SetUpTestCase()78 void DeviceAuthInterfaceTest::SetUpTestCase() {}
TearDownTestCase()79 void DeviceAuthInterfaceTest::TearDownTestCase() {}
SetUp()80 void DeviceAuthInterfaceTest::SetUp() {}
TearDown()81 void DeviceAuthInterfaceTest::TearDown() {}
82 
CreateSessionTest(int32_t * sessionId,const cJSON * in,cJSON * out)83 static int32_t CreateSessionTest(int32_t *sessionId, const cJSON *in, cJSON *out)
84 {
85     (void)sessionId;
86     (void)in;
87     (void)out;
88     return HC_SUCCESS;
89 }
90 
ExcuteCredMgrCmdTest(int32_t osAccount,int32_t cmdId,const cJSON * in,cJSON * out)91 static int32_t ExcuteCredMgrCmdTest(int32_t osAccount, int32_t cmdId, const cJSON *in, cJSON *out)
92 {
93     (void)osAccount;
94     (void)cmdId;
95     (void)in;
96     (void)out;
97     return HC_SUCCESS;
98 }
99 
ProcessSessionTest(int32_t * sessionId,const cJSON * in,cJSON * out,int32_t * status)100 static int32_t ProcessSessionTest(int32_t *sessionId, const cJSON *in, cJSON *out, int32_t *status)
101 {
102     (void)sessionId;
103     (void)in;
104     (void)out;
105     (void)status;
106     return HC_SUCCESS;
107 }
108 
DestroySessionTest(int32_t sessionId)109 static int32_t DestroySessionTest(int32_t sessionId)
110 {
111     (void)sessionId;
112     return HC_SUCCESS;
113 }
114 
InitTest(struct ExtPlugin * extPlugin,const cJSON * params,const struct ExtPluginCtx * context)115 static int32_t InitTest(struct ExtPlugin *extPlugin, const cJSON *params, const struct ExtPluginCtx *context)
116 {
117     (void)extPlugin;
118     (void)params;
119     (void)context;
120     return HC_SUCCESS;
121 }
122 
Destroy(struct ExtPlugin * extPlugin)123 static void Destroy(struct ExtPlugin *extPlugin)
124 {
125     (void)extPlugin;
126 }
127 
128 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest001, TestSize.Level0)
129 {
130     // account_auth_plugin_proxy.c interface test
131     int32_t res = SetAccountAuthPlugin(nullptr, nullptr);
132     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
133     res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
134     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
135     res = CreateAuthSession(0, nullptr, nullptr);
136     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
137     res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
138     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
139     res = DestroyAuthSession(0);
140     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
141     AccountAuthExtPlug plugin = { { 0 }, nullptr, nullptr, nullptr, nullptr };
142     res = SetAccountAuthPlugin(nullptr, &plugin);
143     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
144     res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
145     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
146     res = CreateAuthSession(0, nullptr, nullptr);
147     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
148     res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
149     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
150     res = DestroyAuthSession(0);
151     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
152     plugin.createSession = CreateSessionTest;
153     res = SetAccountAuthPlugin(nullptr, &plugin);
154     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
155     res = CreateAuthSession(0, nullptr, nullptr);
156     ASSERT_EQ(res, HC_SUCCESS);
157     plugin.excuteCredMgrCmd = ExcuteCredMgrCmdTest;
158     res = SetAccountAuthPlugin(nullptr, &plugin);
159     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
160     res = ExcuteCredMgrCmd(DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
161     ASSERT_EQ(res, HC_SUCCESS);
162     plugin.processSession = ProcessSessionTest;
163     res = SetAccountAuthPlugin(nullptr, &plugin);
164     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
165     res = ProcessAuthSession(0, nullptr, nullptr, nullptr);
166     ASSERT_EQ(res, HC_SUCCESS);
167     plugin.destroySession = DestroySessionTest;
168     plugin.base.init = InitTest;
169     res = SetAccountAuthPlugin(nullptr, &plugin);
170     ASSERT_EQ(res, HC_SUCCESS);
171     res = DestroyAuthSession(0);
172     ASSERT_EQ(res, HC_SUCCESS);
173     DestoryAccountAuthPlugin();
174 }
175 
176 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest002, TestSize.Level0)
177 {
178     // account_auth_plugin_proxy.c interface test
179     int32_t res = SetAccountAuthPlugin(nullptr, nullptr);
180     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
181     DestoryAccountAuthPlugin();
182     AccountAuthExtPlug plugin = { { 0 }, nullptr, nullptr, nullptr, nullptr };
183     res = SetAccountAuthPlugin(nullptr, &plugin);
184     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
185     DestoryAccountAuthPlugin();
186     plugin.base.destroy = Destroy;
187     res = SetAccountAuthPlugin(nullptr, &plugin);
188     ASSERT_EQ(res, HC_ERR_INVALID_PARAMS);
189     DestoryAccountAuthPlugin();
190 }
191 
192 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest003, TestSize.Level0)
193 {
194     // pake_protocol_dl_common.c interface test
195     uint32_t alg = GetPakeDlAlg();
196     ASSERT_EQ(alg, PAKE_ALG_DL);
197     PakeBaseParams *baseParams = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
198     baseParams->loader = GetLoaderInstance();
199     baseParams->isClient = true;
200     int32_t res = GenerateDlPakeParams(baseParams, nullptr);
201     ASSERT_EQ(res, HC_ERR_INVALID_LEN);
202     baseParams->epkPeer.length = PAKE_DL_PRIME_LEN;
203     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
204     res = GenerateDlPakeParams(baseParams, nullptr);
205     ASSERT_NE(res, HC_SUCCESS);
206     baseParams->epkPeer.length = PAKE_DL_PRIME_SMALL_LEN;
207     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
208     ASSERT_NE(res, HC_SUCCESS);
209     baseParams->isClient = false;
210     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
211     res = GenerateDlPakeParams(baseParams, nullptr);
212     ASSERT_NE(res, HC_SUCCESS);
213     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
214     res = GenerateDlPakeParams(baseParams, nullptr);
215     ASSERT_NE(res, HC_SUCCESS);
216     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_NONE;
217     res = GenerateDlPakeParams(baseParams, nullptr);
218     ASSERT_NE(res, HC_SUCCESS);
219     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
220     uint8_t secretVal[16] = { 0 };
221     Uint8Buff secret = { secretVal, 16 };
222     res = GenerateDlPakeParams(baseParams, &secret);
223     ASSERT_EQ(res, HC_SUCCESS);
224     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_NONE;
225     res = AgreeDlSharedSecret(baseParams, nullptr);
226     ASSERT_NE(res, HC_SUCCESS);
227     baseParams->epkPeer.length = PAKE_DL_PRIME_LEN;
228     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_384;
229     res = AgreeDlSharedSecret(baseParams, nullptr);
230     ASSERT_NE(res, HC_SUCCESS);
231     baseParams->epkPeer.length = PAKE_DL_PRIME_SMALL_LEN;
232     baseParams->supportedDlPrimeMod = DL_PRIME_MOD_256;
233     res = AgreeDlSharedSecret(baseParams, nullptr);
234     ASSERT_NE(res, HC_SUCCESS);
235     HcFree(baseParams);
236 }
237 
ConstructPakeV1InParams(CJson * in)238 static void ConstructPakeV1InParams(CJson *in)
239 {
240     (void)AddIntToJson(in, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
241     (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
242     (void)AddIntToJson(in, FIELD_SELF_TYPE, 0);
243     (void)AddStringToJson(in, FIELD_PKG_NAME, "testPkgName");
244     (void)AddStringToJson(in, FIELD_SERVICE_TYPE, "TestServiceType");
245     (void)AddStringToJson(in, FIELD_SELF_AUTH_ID, "TestAuthId");
246     (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, "TestPeerAuthId");
247     (void)AddBoolToJson(in, FIELD_IS_SELF_FROM_UPGRADE, true);
248     (void)AddBoolToJson(in, FIELD_IS_PEER_FROM_UPGRADE, true);
249 }
250 
251 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest004, TestSize.Level0)
252 {
253     // pake_v1_protocol_task_common.c interface test
254     DestroyDasPakeV1Params(nullptr);
255     PakeParams *params = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
256     params->pseudonymExtInfo.selfNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
257     ASSERT_NE(params->pseudonymExtInfo.selfNextPseudonymId.val, nullptr);
258     params->pseudonymExtInfo.selfNextPseudonymChallenge.val = (uint8_t *)HcMalloc(16, 0);
259     ASSERT_NE(params->pseudonymExtInfo.selfNextPseudonymChallenge.val, nullptr);
260     params->pseudonymExtInfo.peerNextPseudonymId.val = (uint8_t *)HcMalloc(16, 0);
261     ASSERT_NE(params->pseudonymExtInfo.peerNextPseudonymId.val, nullptr);
262     DestroyDasPakeV1Params(params);
263     CJson *in = CreateJson();
264     ASSERT_NE(in, nullptr);
265     int32_t res = InitDasPakeV1Params(params, in);
266     ASSERT_NE(res, HC_SUCCESS);
267     ConstructPakeV1InParams(in);
268     res = InitDasPakeV1Params(params, in);
269     ASSERT_EQ(res, HC_SUCCESS);
270     res = LoadPseudonymExtInfoIfNeed(nullptr);
271     ASSERT_NE(res, HC_SUCCESS);
272     res = LoadPseudonymExtInfoIfNeed(params);
273     ASSERT_NE(res, HC_SUCCESS);
274     res = AddPseudonymIdAndChallenge(nullptr, nullptr);
275     ASSERT_NE(res, HC_SUCCESS);
276     res = AddPseudonymIdAndChallenge(params, nullptr);
277     ASSERT_NE(res, HC_SUCCESS);
278     CJson *payload = CreateJson();
279     ASSERT_NE(payload, nullptr);
280     res = AddPseudonymIdAndChallenge(params, payload);
281     ASSERT_NE(res, HC_SUCCESS);
282     res = CheckPseudonymId(nullptr, nullptr);
283     ASSERT_NE(res, HC_SUCCESS);
284     res = CheckPseudonymId(params, nullptr);
285     ASSERT_NE(res, HC_SUCCESS);
286     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
287     res = CheckPseudonymId(params, in);
288     ASSERT_NE(res, HC_SUCCESS);
289     (void)AddStringToJson(payload, FIELD_P2P_PSEUDONYM_ID, TEST_PSEUDONYM_ID);
290     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
291     res = CheckPseudonymId(params, in);
292     ASSERT_NE(res, HC_SUCCESS);
293     (void)AddStringToJson(payload, FIELD_PSEUDONYM_CHALLENGE, TEST_PSEUDONYM_CHALLENGE);
294     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
295     res = CheckPseudonymId(params, in);
296     ASSERT_NE(res, HC_SUCCESS);
297     FreeJson(in);
298     FreeJson(payload);
299     DestroyDasPakeV1Params(params);
300     HcFree(params);
301 }
302 
303 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest005, TestSize.Level0)
304 {
305     // ipc_adapt.cpp interface test
306     int32_t res = InitIpcCallBackList();
307     ASSERT_EQ(res, HC_SUCCESS);
308     res = InitIpcCallBackList();
309     ASSERT_EQ(res, HC_SUCCESS);
310     DeInitIpcCallBackList();
311     DeInitIpcCallBackList();
312     ResetIpcCallBackNodeByNodeId(-1);
313     ResetIpcCallBackNodeByNodeId(65);
314     ResetIpcCallBackNodeByNodeId(1);
315     res = InitIpcCallBackList();
316     ASSERT_EQ(res, HC_SUCCESS);
317     ResetIpcCallBackNodeByNodeId(1);
318     DeInitIpcCallBackList();
319     AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
320     (void)InitIpcCallBackList();
321     AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
322     DeInitIpcCallBackList();
323     AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
324     (void)InitIpcCallBackList();
325     AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
326     DeInitIpcCallBackList();
327     DelIpcCallBackByAppId(TEST_APP_ID, 0);
328     (void)InitIpcCallBackList();
329     DelIpcCallBackByAppId(TEST_APP_ID, 0);
330     DeInitIpcCallBackList();
331     res = AddReqIdByAppId(TEST_APP_ID, 123);
332     ASSERT_NE(res, HC_SUCCESS);
333     (void)InitIpcCallBackList();
334     res = AddReqIdByAppId(TEST_APP_ID, 123);
335     ASSERT_NE(res, HC_SUCCESS);
336     DeInitIpcCallBackList();
337     AddIpcCbObjByReqId(123, 0, 0);
338     (void)InitIpcCallBackList();
339     AddIpcCbObjByReqId(123, 0, 0);
340     DeInitIpcCallBackList();
341     res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
342     ASSERT_NE(res, HC_SUCCESS);
343     (void)InitIpcCallBackList();
344     res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
345     ASSERT_NE(res, HC_SUCCESS);
346     DeInitIpcCallBackList();
347     DelIpcCallBackByReqId(123, 0, true);
348     DelIpcCallBackByReqId(123, 0, false);
349 }
350 
351 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest006, TestSize.Level0)
352 {
353     // ipc_adapt.cpp interface test
354     InitDeviceAuthCbCtx(nullptr, 0);
355     DeviceAuthCallback callback = { 0 };
356     InitDeviceAuthCbCtx(&callback, 1);
357     InitDeviceAuthCbCtx(&callback, 2);
358     InitDevAuthListenerCbCtx(nullptr);
359     DataChangeListener listener = { 0 };
360     InitDevAuthListenerCbCtx(&listener);
361     uintptr_t ptr = 0;
362     int32_t res = CreateServiceInstance(&ptr);
363     ASSERT_EQ(res, HC_SUCCESS);
364     DestroyServiceInstance(ptr);
365     bool isCallback = IsCallbackMethod(0);
366     ASSERT_EQ(isCallback, false);
367     isCallback = IsCallbackMethod(1);
368     ASSERT_EQ(isCallback, true);
369 }
370 
371 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest007, TestSize.Level0)
372 {
373     // mk_agree_task.c interface test
374     int32_t res = CreateMkAgreeTask(0, nullptr, nullptr);
375     ASSERT_NE(res, HC_SUCCESS);
376     CJson *in = CreateJson();
377     ASSERT_NE(in, nullptr);
378     res = CreateMkAgreeTask(0, in, nullptr);
379     ASSERT_NE(res, HC_SUCCESS);
380     MkAgreeTaskBase *task = nullptr;
381     res = CreateMkAgreeTask(0, in, &task);
382     ASSERT_NE(res, HC_SUCCESS);
383     (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
384     res = CreateMkAgreeTask(TASK_TYPE_ISO, in, &task);
385     ASSERT_NE(res, HC_SUCCESS);
386     res = CreateMkAgreeTask(2, in, &task);
387     ASSERT_NE(res, HC_SUCCESS);
388     FreeJson(in);
389 }
390 
InitCredPlugin(void)391 static int32_t InitCredPlugin(void)
392 {
393     return HC_SUCCESS;
394 }
395 
InitCredPluginFail(void)396 static int32_t InitCredPluginFail(void)
397 {
398     return HC_ERROR;
399 }
400 
DestroyCredPlugin(void)401 static void DestroyCredPlugin(void) {}
402 
ProcessCredTest(int32_t osAccountId,int32_t cmdId,CJson * in,CJson * out)403 static int32_t ProcessCredTest(int32_t osAccountId, int32_t cmdId, CJson *in, CJson *out)
404 {
405     (void)osAccountId;
406     (void)cmdId;
407     (void)in;
408     (void)out;
409     return HC_SUCCESS;
410 }
411 
412 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest008, TestSize.Level0)
413 {
414     // cred_manager.c interface test
415     int32_t res = InitCredMgr();
416     ASSERT_EQ(res, HC_SUCCESS);
417     res = ProcCred(0, DEFAULT_OS_ACCOUNT, 0, nullptr, nullptr);
418     ASSERT_NE(res, HC_SUCCESS);
419     res = AddCredPlugin(nullptr);
420     ASSERT_NE(res, HC_SUCCESS);
421     CredPlugin plugin = { 0 };
422     res = AddCredPlugin(&plugin);
423     ASSERT_NE(res, HC_SUCCESS);
424     plugin.init = InitCredPlugin;
425     res = AddCredPlugin(&plugin);
426     ASSERT_NE(res, HC_SUCCESS);
427     plugin.destroy = DestroyCredPlugin;
428     res = AddCredPlugin(&plugin);
429     ASSERT_NE(res, HC_SUCCESS);
430     plugin.procCred = ProcessCredTest;
431     res = AddCredPlugin(&plugin);
432     ASSERT_EQ(res, HC_SUCCESS);
433     plugin.init = InitCredPluginFail;
434     res = AddCredPlugin(&plugin);
435     ASSERT_NE(res, HC_SUCCESS);
436     plugin.init = InitCredPlugin;
437     res = AddCredPlugin(&plugin);
438     ASSERT_EQ(res, HC_SUCCESS);
439     DelCredPlugin(0);
440     DestroyCredMgr();
441 }
442 
OnChannelOpenedTest(int64_t requestId,int result)443 static int OnChannelOpenedTest(int64_t requestId, int result)
444 {
445     (void)requestId;
446     (void)result;
447     return 0;
448 }
449 
OnChannelClosedTest(void)450 static void OnChannelClosedTest(void) {}
451 
OnBytesReceivedTest(int64_t requestId,uint8_t * data,uint32_t dataLen)452 static void OnBytesReceivedTest(int64_t requestId, uint8_t *data, uint32_t dataLen)
453 {
454     (void)requestId;
455     (void)data;
456     (void)dataLen;
457 }
458 
OnTransmit(int64_t requestId,const uint8_t * data,uint32_t dataLen)459 static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
460 {
461     (void)requestId;
462     (void)data;
463     (void)dataLen;
464     return true;
465 }
466 
467 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest009, TestSize.Level0)
468 {
469     // channel_manager.c interface test
470     ChannelProxy proxy = { 0 };
471     proxy.onBytesReceived = OnBytesReceivedTest;
472     proxy.onChannelClosed = OnChannelClosedTest;
473     proxy.onChannelOpened = OnChannelOpenedTest;
474     int32_t res = InitChannelManager(&proxy);
475     ASSERT_NE(res, HC_SUCCESS);
476     DeviceAuthCallback callback = { 0 };
477     CJson *jsonParams = CreateJson();
478     ASSERT_NE(jsonParams, nullptr);
479     ChannelType type = GetChannelType(&callback, jsonParams);
480     ASSERT_EQ(type, NO_CHANNEL);
481     (void)AddStringToJson(jsonParams, FIELD_CONNECT_PARAMS, TEST_CONNECT_PARAMS);
482     type = GetChannelType(&callback, jsonParams);
483     ASSERT_EQ(type, SOFT_BUS);
484     FreeJson(jsonParams);
485     jsonParams = CreateJson();
486     ASSERT_NE(jsonParams, nullptr);
487     callback.onTransmit = OnTransmit;
488     type = GetChannelType(&callback, jsonParams);
489     ASSERT_EQ(type, SERVICE_CHANNEL);
490     FreeJson(jsonParams);
491     res = OpenChannel(SERVICE_CHANNEL, nullptr, 123, nullptr);
492     ASSERT_NE(res, HC_SUCCESS);
493     jsonParams = CreateJson();
494     ASSERT_NE(jsonParams, nullptr);
495     int64_t returnChannelId = 0;
496     res = OpenChannel(SOFT_BUS, jsonParams, 123, &returnChannelId);
497     ASSERT_NE(res, HC_SUCCESS);
498     (void)AddStringToJson(jsonParams, FIELD_CONNECT_PARAMS, TEST_CONNECT_PARAMS);
499     res = OpenChannel(SOFT_BUS, jsonParams, 123, &returnChannelId);
500     ASSERT_NE(res, HC_SUCCESS);
501     FreeJson(jsonParams);
502     res = OpenChannel(NO_CHANNEL, nullptr, 123, &returnChannelId);
503     ASSERT_NE(res, HC_SUCCESS);
504     CloseChannel(SOFT_BUS, 0);
505     res = HcSendMsg(SOFT_BUS, 123, 0, nullptr, TEST_TRANSMIT_DATA);
506     ASSERT_NE(res, HC_SUCCESS);
507     res = HcSendMsg(NO_CHANNEL, 123, 00, nullptr, nullptr);
508     ASSERT_NE(res, HC_SUCCESS);
509     res = HcSendMsg(SERVICE_CHANNEL, 123, 0, nullptr, nullptr);
510     ASSERT_NE(res, HC_SUCCESS);
511     NotifyBindResult(SOFT_BUS, 0);
512     DestroyChannelManager();
513 }
514 
InitModuleTest(void)515 static int32_t InitModuleTest(void)
516 {
517     return HC_SUCCESS;
518 }
519 
InitModuleFail(void)520 static int32_t InitModuleFail(void)
521 {
522     return HC_ERROR;
523 }
524 
DestroyModuleTest(void)525 static void DestroyModuleTest(void) {}
526 
CreateTaskTest(int32_t * taskId,const CJson * in,CJson * out)527 static int CreateTaskTest(int32_t *taskId, const CJson *in, CJson *out)
528 {
529     (void)taskId;
530     (void)in;
531     (void)out;
532     return HC_SUCCESS;
533 }
534 
ProcessTaskTest(int32_t taskId,const CJson * in,CJson * out,int32_t * status)535 static int ProcessTaskTest(int32_t taskId, const CJson *in, CJson *out, int32_t *status)
536 {
537     (void)taskId;
538     (void)in;
539     (void)out;
540     (void)status;
541     return HC_SUCCESS;
542 }
543 
DestroyTaskTest(int taskId)544 static void DestroyTaskTest(int taskId)
545 {
546     (void)taskId;
547 }
548 
549 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest010, TestSize.Level0)
550 {
551     // dev_auth_module_manager.c interface test
552     AuthModuleParams params = { DEFAULT_OS_ACCOUNT, TEST_APP_ID, TEST_GROUP_ID, nullptr, 0 };
553     int32_t res = UnregisterLocalIdentity(&params, ACCOUNT_MODULE);
554     ASSERT_NE(res, HC_SUCCESS);
555     InitModules();
556     Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, strlen(TEST_AUTH_ID) };
557     params.authId = &authIdBuff;
558     res = UnregisterLocalIdentity(&params, DAS_MODULE);
559     ASSERT_EQ(res, HC_SUCCESS);
560     CJson *in = CreateJson();
561     ASSERT_NE(in, nullptr);
562     res = CheckMsgRepeatability(in, DAS_MODULE);
563     ASSERT_EQ(res, HC_SUCCESS);
564     res = UnregisterLocalIdentity(&params, DAS_MODULE);
565     ASSERT_EQ(res, HC_SUCCESS);
566     res = CheckMsgRepeatability(nullptr, DAS_MODULE);
567     ASSERT_NE(res, HC_SUCCESS);
568     res = CheckMsgRepeatability(in, DAS_MODULE);
569     ASSERT_EQ(res, HC_SUCCESS);
570     FreeJson(in);
571     in = CreateJson();
572     ASSERT_NE(in, nullptr);
573     CJson *out = CreateJson();
574     ASSERT_NE(out, nullptr);
575     int32_t taskId = 0;
576     (void)CreateTask(&taskId, in, out, DAS_MODULE);
577     FreeJson(in);
578     FreeJson(out);
579     DestroyTask(0, 0);
580     (void)AddAuthModulePlugin(nullptr);
581     AuthModuleBase plugin = { 0 };
582     (void)AddAuthModulePlugin(&plugin);
583     plugin.init = InitModuleTest;
584     (void)AddAuthModulePlugin(&plugin);
585     plugin.destroy = DestroyModuleTest;
586     (void)AddAuthModulePlugin(&plugin);
587     plugin.createTask = CreateTaskTest;
588     (void)AddAuthModulePlugin(&plugin);
589     plugin.processTask = ProcessTaskTest;
590     (void)AddAuthModulePlugin(&plugin);
591     plugin.destroyTask = DestroyTaskTest;
592     (void)AddAuthModulePlugin(&plugin);
593     plugin.init = InitModuleFail;
594     (void)AddAuthModulePlugin(&plugin);
595     plugin.init = InitModuleTest;
596     res = AddAuthModulePlugin(&plugin);
597     ASSERT_EQ(res, HC_SUCCESS);
598     DelAuthModulePlugin(0);
599     DestroyModules();
600 }
601 
602 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest011, TestSize.Level0)
603 {
604     // mbedtls_ec_adapter.c interface test
605     int32_t res = MbedtlsHashToPoint25519(nullptr, nullptr);
606     ASSERT_NE(res, HC_SUCCESS);
607     uint8_t hashVal[64] = { 0 };
608     Uint8Buff hashBuff = { hashVal, 64 };
609     res = MbedtlsHashToPoint25519(&hashBuff, nullptr);
610     ASSERT_NE(res, HC_SUCCESS);
611     uint8_t outEcPointVal[32] = { 0 };
612     Uint8Buff outEcPointBuff = { outEcPointVal, 32 };
613     res = MbedtlsHashToPoint25519(&hashBuff, &outEcPointBuff);
614     ASSERT_NE(res, HC_SUCCESS);
615     uint8_t validHashVal[32] = { 0 };
616     hashBuff.val = validHashVal;
617     hashBuff.length = 32;
618     res = MbedtlsHashToPoint25519(&hashBuff, &outEcPointBuff);
619     ASSERT_EQ(res, HC_SUCCESS);
620 }
621 
622 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest012, TestSize.Level0)
623 {
624     // account_task_main.c interface test
625     int32_t taskId = 0;
626     AccountTask *task = CreateAccountTaskT(&taskId, nullptr, nullptr);
627     ASSERT_EQ(task, nullptr);
628     CJson *in = CreateJson();
629     ASSERT_NE(in, nullptr);
630     (void)AddIntToJson(in, FIELD_OPERATION_CODE, MEMBER_JOIN);
631     task = CreateAccountTaskT(&taskId, in, nullptr);
632     ASSERT_EQ(task, nullptr);
633     (void)AddIntToJson(in, FIELD_CREDENTIAL_TYPE, 0);
634     task = CreateAccountTaskT(&taskId, in, nullptr);
635     ASSERT_EQ(task, nullptr);
636     InitVersionInfos();
637     (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
638     (void)AddIntToJson(in, FIELD_CREDENTIAL_TYPE, ASYMMETRIC_CRED);
639     task = CreateAccountTaskT(&taskId, in, nullptr);
640     ASSERT_EQ(task, nullptr);
641     CJson *out = CreateJson();
642     ASSERT_NE(out, nullptr);
643     (void)AddIntToJson(in, FIELD_IS_CLIENT, true);
644     task = CreateAccountTaskT(&taskId, in, out);
645     ASSERT_EQ(task, nullptr);
646     (void)AddIntToJson(in, FIELD_IS_CLIENT, false);
647     task = CreateAccountTaskT(&taskId, in, out);
648     ASSERT_EQ(task, nullptr);
649     FreeJson(in);
650     FreeJson(out);
651 }
652 
653 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest013, TestSize.Level0)
654 {
655     // account_module.c interface test
656     const AuthModuleBase *accountModule = GetAccountModule();
657     ASSERT_NE(accountModule, nullptr);
658     int32_t res = accountModule->init();
659     ASSERT_EQ(res, HC_SUCCESS);
660     bool isIgnored = accountModule->isMsgNeedIgnore(nullptr);
661     ASSERT_EQ(isIgnored, true);
662     CJson *in = CreateJson();
663     ASSERT_NE(in, nullptr);
664     (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
665     isIgnored = accountModule->isMsgNeedIgnore(in);
666     ASSERT_EQ(isIgnored, false);
667     (void)AddIntToJson(in, FIELD_OPERATION_CODE, OP_BIND);
668     isIgnored = accountModule->isMsgNeedIgnore(in);
669     ASSERT_EQ(isIgnored, false);
670     (void)AddIntToJson(in, FIELD_OPERATION_CODE, OP_UNBIND);
671     isIgnored = accountModule->isMsgNeedIgnore(in);
672     ASSERT_EQ(isIgnored, true);
673     (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
674     (void)AddIntToJson(in, FIELD_STEP, 1);
675     isIgnored = accountModule->isMsgNeedIgnore(in);
676     ASSERT_EQ(isIgnored, true);
677     FreeJson(in);
678     res = accountModule->createTask(nullptr, nullptr, nullptr);
679     ASSERT_NE(res, HC_SUCCESS);
680     int32_t taskId = 0;
681     res = accountModule->createTask(&taskId, nullptr, nullptr);
682     ASSERT_NE(res, HC_SUCCESS);
683     in = CreateJson();
684     ASSERT_NE(in, nullptr);
685     res = accountModule->createTask(&taskId, in, nullptr);
686     ASSERT_NE(res, HC_SUCCESS);
687     CJson *out = CreateJson();
688     ASSERT_NE(out, nullptr);
689     res = accountModule->createTask(&taskId, in, out);
690     ASSERT_NE(res, HC_SUCCESS);
691     (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
692     (void)AddIntToJson(in, FIELD_STEP, 0);
693     res = accountModule->createTask(&taskId, in, out);
694     FreeJson(in);
695     FreeJson(out);
696     res = accountModule->processTask(0, nullptr, nullptr, nullptr);
697     accountModule->destroyTask(0);
698     AccountMultiTaskManager *manager = GetAccountMultiTaskManager();
699     (void)manager->addTaskToManager(nullptr);
700     (void)manager->getTaskFromManager(1);
701     accountModule->destroy();
702 }
703 
704 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest014, TestSize.Level0)
705 {
706     // identical_account_group.c interface test
707     (void)InitDatabase();
708     (void)InitBroadcastManager();
709     IdenticalAccountGroup *group = (IdenticalAccountGroup *)GetIdenticalAccountGroupInstance();
710     ASSERT_NE(group, nullptr);
711     int32_t res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
712     ASSERT_NE(res, HC_SUCCESS);
713     res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
714     ASSERT_NE(res, HC_SUCCESS);
715     CJson *jsonParams = CreateJson();
716     ASSERT_NE(jsonParams, nullptr);
717     res = group->delMultiMembersFromGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, jsonParams);
718     ASSERT_NE(res, HC_SUCCESS);
719     res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
720     ASSERT_NE(res, HC_SUCCESS);
721     res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, nullptr);
722     ASSERT_NE(res, HC_SUCCESS);
723     res = group->addMultiMembersToGroup(DEFAULT_OS_ACCOUNT, TEST_APP_ID, jsonParams);
724     ASSERT_NE(res, HC_SUCCESS);
725     res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
726     ASSERT_NE(res, HC_SUCCESS);
727     res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, nullptr);
728     ASSERT_NE(res, HC_SUCCESS);
729     char *returnJsonStr = nullptr;
730     res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
731     ASSERT_NE(res, HC_SUCCESS);
732     res = group->base.createGroup(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
733     ASSERT_NE(res, HC_SUCCESS);
734     res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, nullptr);
735     ASSERT_NE(res, HC_SUCCESS);
736     res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
737     ASSERT_NE(res, HC_SUCCESS);
738     (void)AddStringToJson(jsonParams, FIELD_APP_ID, TEST_APP_ID);
739     res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
740     ASSERT_NE(res, HC_SUCCESS);
741     (void)AddStringToJson(jsonParams, FIELD_USER_ID, TEST_GROUP_ID);
742     res = group->base.createGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
743     ASSERT_NE(res, HC_SUCCESS);
744     (void)AddStringToJson(jsonParams, FIELD_GROUP_ID, TEST_GROUP_ID);
745     res = group->base.deleteGroup(DEFAULT_OS_ACCOUNT, jsonParams, &returnJsonStr);
746     ASSERT_EQ(res, HC_SUCCESS);
747     DestroyDatabase();
748     DestroyBroadcastManager();
749 }
750 
OnGroupCreated(const char * groupInfo)751 static void OnGroupCreated(const char *groupInfo)
752 {
753     (void)groupInfo;
754 }
755 
OnGroupDeleted(const char * groupInfo)756 static void OnGroupDeleted(const char *groupInfo)
757 {
758     (void)groupInfo;
759 }
760 
OnDeviceBound(const char * peerUdid,const char * groupInfo)761 static void OnDeviceBound(const char *peerUdid, const char *groupInfo)
762 {
763     (void)peerUdid;
764     (void)groupInfo;
765 }
766 
OnDeviceUnBound(const char * peerUdid,const char * groupInfo)767 static void OnDeviceUnBound(const char *peerUdid, const char *groupInfo)
768 {
769     (void)peerUdid;
770     (void)groupInfo;
771 }
772 
OnDeviceNotTrusted(const char * peerUdid)773 static void OnDeviceNotTrusted(const char *peerUdid)
774 {
775     (void)peerUdid;
776 }
777 
OnLastGroupDeleted(const char * peerUdid,int groupType)778 static void OnLastGroupDeleted(const char *peerUdid, int groupType)
779 {
780     (void)peerUdid;
781     (void)groupType;
782 }
783 
OnTrustedDeviceNumChanged(int curTrustedDeviceNum)784 static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum)
785 {
786     (void)curTrustedDeviceNum;
787 }
788 
789 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest015, TestSize.Level0)
790 {
791     // broadcast_manager.c interface test
792     int32_t res = InitBroadcastManager();
793     ASSERT_EQ(res, HC_SUCCESS);
794     res = AddListener(nullptr, nullptr);
795     ASSERT_NE(res, HC_SUCCESS);
796     res = AddListener(TEST_APP_ID, nullptr);
797     ASSERT_NE(res, HC_SUCCESS);
798     DataChangeListener listener = { 0 };
799     res = AddListener(TEST_APP_ID, &listener);
800     ASSERT_EQ(res, HC_SUCCESS);
801     res = RemoveListener(nullptr);
802     ASSERT_NE(res, HC_SUCCESS);
803     res = RemoveListener(TEST_APP_ID);
804     ASSERT_EQ(res, HC_SUCCESS);
805     const Broadcaster *broadcaster = GetBroadcaster();
806     ASSERT_NE(broadcaster, nullptr);
807     listener.onDeviceBound = OnDeviceBound;
808     listener.onDeviceNotTrusted = OnDeviceNotTrusted;
809     listener.onDeviceUnBound = OnDeviceUnBound;
810     listener.onGroupCreated = OnGroupCreated;
811     listener.onGroupDeleted = OnGroupDeleted;
812     listener.onLastGroupDeleted = OnLastGroupDeleted;
813     listener.onTrustedDeviceNumChanged = OnTrustedDeviceNumChanged;
814     res = AddListener(TEST_APP_ID, &listener);
815     ASSERT_EQ(res, HC_SUCCESS);
816     broadcaster->postOnTrustedDeviceNumChanged(1);
817     broadcaster->postOnLastGroupDeleted(nullptr, PEER_TO_PEER_GROUP);
818     broadcaster->postOnLastGroupDeleted(TEST_AUTH_ID, PEER_TO_PEER_GROUP);
819     broadcaster->postOnGroupDeleted(nullptr);
820     broadcaster->postOnGroupDeleted("test");
821     broadcaster->postOnGroupCreated(nullptr);
822     broadcaster->postOnGroupCreated("test");
823     broadcaster->postOnDeviceUnBound(nullptr, nullptr);
824     broadcaster->postOnDeviceUnBound(TEST_AUTH_ID, nullptr);
825     broadcaster->postOnDeviceUnBound(TEST_AUTH_ID, "test");
826     broadcaster->postOnDeviceNotTrusted(nullptr);
827     broadcaster->postOnDeviceNotTrusted(TEST_AUTH_ID);
828     broadcaster->postOnDeviceBound(nullptr, nullptr);
829     broadcaster->postOnDeviceBound(TEST_AUTH_ID, nullptr);
830     broadcaster->postOnDeviceBound(TEST_AUTH_ID, "test");
831     res = RemoveListener(TEST_APP_ID);
832     ASSERT_EQ(res, HC_SUCCESS);
833     DestroyBroadcastManager();
834 }
835 
836 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest016, TestSize.Level0)
837 {
838     // iso_protocol_common.c interface test
839     int res = IsoServerGenSessionKeyAndCalToken(nullptr, nullptr, nullptr);
840     ASSERT_NE(res, HC_SUCCESS);
841     IsoBaseParams *baseParams = (IsoBaseParams *)HcMalloc(sizeof(IsoBaseParams), 0);
842     baseParams->loader = GetLoaderInstance();
843     res = IsoServerGenSessionKeyAndCalToken(baseParams, nullptr, nullptr);
844     ASSERT_NE(res, HC_SUCCESS);
845     Uint8Buff tokenFromPeer = { 0 };
846     res = IsoServerGenSessionKeyAndCalToken(baseParams, &tokenFromPeer, nullptr);
847     ASSERT_NE(res, HC_SUCCESS);
848     Uint8Buff tokenToPeer = { 0 };
849     res = IsoServerGenSessionKeyAndCalToken(baseParams, &tokenFromPeer, &tokenToPeer);
850     ASSERT_NE(res, HC_SUCCESS);
851     res = IsoServerGenRandomAndToken(nullptr, nullptr);
852     ASSERT_NE(res, HC_SUCCESS);
853     res = IsoServerGenRandomAndToken(baseParams, nullptr);
854     ASSERT_NE(res, HC_SUCCESS);
855     res = IsoClientGenSessionKey(nullptr, 0, nullptr, 0);
856     ASSERT_NE(res, HC_SUCCESS);
857     res = IsoClientGenSessionKey(baseParams, 0, nullptr, 0);
858     ASSERT_NE(res, HC_SUCCESS);
859     uint8_t hmacVal[256] = { 0 };
860     res = IsoClientGenSessionKey(baseParams, 0, hmacVal, 256);
861     ASSERT_NE(res, HC_SUCCESS);
862     res = IsoClientCheckAndGenToken(nullptr, nullptr, nullptr);
863     ASSERT_NE(res, HC_SUCCESS);
864     res = IsoClientCheckAndGenToken(baseParams, nullptr, nullptr);
865     ASSERT_NE(res, HC_SUCCESS);
866     Uint8Buff peerToken = { 0 };
867     res = IsoClientCheckAndGenToken(baseParams, &peerToken, nullptr);
868     ASSERT_NE(res, HC_SUCCESS);
869     Uint8Buff selfToken = { 0 };
870     res = IsoClientCheckAndGenToken(baseParams, &peerToken, &selfToken);
871     ASSERT_NE(res, HC_SUCCESS);
872     res = IsoClientGenRandom(nullptr);
873     ASSERT_NE(res, HC_SUCCESS);
874     HcFree(baseParams);
875 }
876 
877 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest017, TestSize.Level0)
878 {
879     // das_lite_token_manager.c interface test
880     const TokenManager *liteManager = GetLiteTokenManagerInstance();
881     ASSERT_NE(liteManager, nullptr);
882     Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, strlen(TEST_AUTH_ID) };
883     TokenManagerParams params = {
884         .osAccountId = DEFAULT_OS_ACCOUNT,
885         .pkgName = { (uint8_t *)TEST_APP_ID, HcStrlen(TEST_APP_ID) },
886         .serviceType = { (uint8_t *)TEST_GROUP_ID, HcStrlen(TEST_GROUP_ID) },
887         .authId = authIdBuff,
888         .userType = 0
889     };
890     int32_t res = liteManager->unregisterLocalIdentity(&params);
891     ASSERT_EQ(res, HC_SUCCESS);
892     // das_standard_token_manager.c interface test
893     const TokenManager *standardMgr = GetStandardTokenManagerInstance();
894     ASSERT_NE(standardMgr, nullptr);
895     params.pkgName.val = (uint8_t *)GROUP_MANAGER_PACKAGE_NAME;
896     params.pkgName.length = HcStrlen(GROUP_MANAGER_PACKAGE_NAME);
897     res = standardMgr->unregisterLocalIdentity(&params);
898     ASSERT_EQ(res, HC_SUCCESS);
899     params.pkgName.val = (uint8_t *)TEST_APP_ID;
900     params.pkgName.length = HcStrlen(TEST_APP_ID);
901     res = standardMgr->deletePeerAuthInfo(&params);
902     ASSERT_EQ(res, HC_SUCCESS);
903     PakeParams *pakeParams = (PakeParams *)HcMalloc(sizeof(PakeParams), 0);
904     pakeParams->baseParams.loader = GetLoaderInstance();
905     char appId[256] = TEST_APP_ID;
906     char groupId[256] = TEST_GROUP_ID;
907     pakeParams->packageName = appId;
908     pakeParams->serviceType = groupId;
909     pakeParams->baseParams.idSelf.val = (uint8_t *)TEST_AUTH_ID;
910     pakeParams->baseParams.idSelf.length = strlen(TEST_AUTH_ID);
911     pakeParams->isSelfFromUpgrade = true;
912     pakeParams->baseParams.idPeer.val = (uint8_t *)TEST_AUTH_ID;
913     pakeParams->baseParams.idPeer.length = strlen(TEST_AUTH_ID);
914     res = standardMgr->computeAndSavePsk(pakeParams);
915     ASSERT_NE(res, HC_SUCCESS);
916     Uint8Buff returnPkBuff = { 0 };
917     res = standardMgr->getPublicKey(&params, &returnPkBuff);
918     ASSERT_NE(res, HC_SUCCESS);
919     HcFree(pakeParams);
920 }
921 
922 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest018, TestSize.Level0)
923 {
924     // key_manager.c interface test
925     int32_t res = GetDevicePubKey(DEFAULT_OS_ACCOUNT, nullptr);
926     ASSERT_NE(res, HC_SUCCESS);
927     res = DeletePseudonymPsk(DEFAULT_OS_ACCOUNT, nullptr);
928     ASSERT_NE(res, HC_SUCCESS);
929 }
930 
931 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest019, TestSize.Level0)
932 {
933     // group_auth_data_operation.c interface test
934     (void)InitDatabase();
935     int32_t authForm = GroupTypeToAuthForm(ACROSS_ACCOUNT_AUTHORIZE_GROUP);
936     ASSERT_EQ(authForm, AUTH_FORM_ACROSS_ACCOUNT);
937     authForm = GroupTypeToAuthForm(0);
938     ASSERT_EQ(authForm, AUTH_FORM_INVALID_TYPE);
939     int32_t groupType = AuthFormToGroupType(AUTH_FORM_ACCOUNT_UNRELATED);
940     ASSERT_EQ(groupType, PEER_TO_PEER_GROUP);
941     groupType = AuthFormToGroupType(AUTH_FORM_ACROSS_ACCOUNT);
942     ASSERT_EQ(groupType, ACROSS_ACCOUNT_AUTHORIZE_GROUP);
943     groupType = AuthFormToGroupType(-1);
944     ASSERT_EQ(groupType, GROUP_TYPE_INVALID);
945     int32_t res = GaGetTrustedDeviceEntryById(DEFAULT_OS_ACCOUNT, nullptr, true, nullptr, nullptr);
946     ASSERT_NE(res, HC_SUCCESS);
947     bool isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, nullptr, nullptr);
948     ASSERT_EQ(isAccessiblle, false);
949     isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, TEST_GROUP_ID, nullptr);
950     ASSERT_EQ(isAccessiblle, false);
951     isAccessiblle = GaIsGroupAccessible(DEFAULT_OS_ACCOUNT, TEST_GROUP_ID, TEST_APP_ID);
952     ASSERT_EQ(isAccessiblle, false);
953     DestroyDatabase();
954 }
955 
956 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest020, TestSize.Level0)
957 {
958     // compatible_bind_sub_session_util.c interface test
959     InformPeerProcessError(123, nullptr, nullptr, -1);
960     CJson *jsonParams = CreateJson();
961     ASSERT_NE(jsonParams, nullptr);
962     (void)AddStringToJson(jsonParams, FIELD_CHANNEL_ID, "0");
963     InformPeerProcessError(123, jsonParams, nullptr, -1);
964     (void)AddStringToJson(jsonParams, FIELD_APP_ID, TEST_APP_ID);
965     InformPeerProcessError(123, jsonParams, nullptr, -1);
966     FreeJson(jsonParams);
967     int32_t res = CombineConfirmData(MEMBER_JOIN, nullptr, nullptr);
968     ASSERT_NE(res, HC_SUCCESS);
969     res = CombineConfirmData(MEMBER_INVITE, nullptr, nullptr);
970     ASSERT_NE(res, HC_SUCCESS);
971     // compatible_bind_sub_session.c interface test
972     DestroyCompatibleBindSubSession(nullptr);
973     res = CreateServerBindSubSession(nullptr, nullptr, nullptr);
974     ASSERT_NE(res, HC_SUCCESS);
975     jsonParams = CreateJson();
976     ASSERT_NE(jsonParams, nullptr);
977     (void)AddStringToJson(jsonParams, FIELD_REQUEST_ID, "123");
978     res = CreateServerBindSubSession(jsonParams, nullptr, nullptr);
979     ASSERT_NE(res, HC_SUCCESS);
980     (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_INVITE);
981     res = CreateServerBindSubSession(jsonParams, nullptr, nullptr);
982     ASSERT_NE(res, HC_SUCCESS);
983     FreeJson(jsonParams);
984     res = CreateClientBindSubSession(nullptr, nullptr, nullptr);
985     ASSERT_NE(res, HC_SUCCESS);
986     jsonParams = CreateJson();
987     ASSERT_NE(jsonParams, nullptr);
988     (void)AddStringToJson(jsonParams, FIELD_REQUEST_ID, "123");
989     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
990     ASSERT_NE(res, HC_SUCCESS);
991     (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_INVITE);
992     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
993     ASSERT_NE(res, HC_SUCCESS);
994     (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_JOIN);
995     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
996     ASSERT_NE(res, HC_SUCCESS);
997     (void)AddIntToJson(jsonParams, FIELD_GROUP_TYPE, IDENTICAL_ACCOUNT_GROUP);
998     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
999     ASSERT_NE(res, HC_SUCCESS);
1000     (void)AddIntToJson(jsonParams, FIELD_GROUP_TYPE, PEER_TO_PEER_GROUP);
1001     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1002     ASSERT_NE(res, HC_SUCCESS);
1003     (void)AddIntToJson(jsonParams, FIELD_GROUP_OP, MEMBER_DELETE);
1004     res = CreateClientBindSubSession(jsonParams, nullptr, nullptr);
1005     ASSERT_NE(res, HC_SUCCESS);
1006     FreeJson(jsonParams);
1007 }
1008 
1009 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest021, TestSize.Level0)
1010 {
1011     // compatible_auth_sub_session_common.c interface test
1012     NotifyPeerAuthError(nullptr, nullptr);
1013     int32_t res = HandleAuthTaskStatus(nullptr, nullptr, IGNORE_MSG, true);
1014     ASSERT_EQ(res, HC_SUCCESS);
1015     res = HandleAuthTaskStatus(nullptr, nullptr, CONTINUE, true);
1016     ASSERT_NE(res, HC_SUCCESS);
1017     res = HandleAuthTaskStatus(nullptr, nullptr, 3, true);
1018     ASSERT_NE(res, HC_SUCCESS);
1019     // compatible_auth_sub_session_util.c interface test
1020     int32_t authType = GetAuthType(AUTH_FORM_ACROSS_ACCOUNT);
1021     ASSERT_EQ(authType, ACCOUNT_RELATED_GROUP_AUTH_TYPE);
1022     authType = GetAuthType(AUTH_FORM_INVALID_TYPE);
1023     ASSERT_EQ(authType, INVALID_GROUP_AUTH_TYPE);
1024     CJson *confirmJsonParams = CreateJson();
1025     ASSERT_NE(confirmJsonParams, nullptr);
1026     (void)AddIntToJson(confirmJsonParams, FIELD_OS_ACCOUNT_ID, INVALID_OS_ACCOUNT);
1027     res = CombineAuthConfirmData(confirmJsonParams, nullptr);
1028     ASSERT_NE(res, HC_SUCCESS);
1029     FreeJson(confirmJsonParams);
1030     int32_t moduleType = GetAuthModuleType(nullptr);
1031     ASSERT_EQ(moduleType, INVALID_MODULE_TYPE);
1032     CJson *in = CreateJson();
1033     ASSERT_NE(in, nullptr);
1034     (void)AddIntToJson(in, FIELD_AUTH_FORM, AUTH_FORM_INVALID_TYPE);
1035     moduleType = GetAuthModuleType(in);
1036     ASSERT_EQ(moduleType, INVALID_MODULE_TYPE);
1037     FreeJson(in);
1038 }
1039 
1040 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest022, TestSize.Level0)
1041 {
1042     // account_unrelated_group_auth.c interface test
1043     BaseGroupAuth *groupAuth = GetAccountUnrelatedGroupAuth();
1044     ASSERT_NE(groupAuth, nullptr);
1045     groupAuth->onFinish(123, nullptr, nullptr, nullptr);
1046     int32_t res = groupAuth->getAuthParamsVecForServer(nullptr, nullptr);
1047     ASSERT_NE(res, HC_SUCCESS);
1048 }
1049 
1050 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest023, TestSize.Level0)
1051 {
1052     // das_task_common.c interface test
1053     int32_t res = GetAndCheckKeyLenOnServer(nullptr, 0);
1054     ASSERT_NE(res, HC_SUCCESS);
1055     CJson *in = CreateJson();
1056     CJson *payload = CreateJson();
1057     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1058     res = GetAndCheckKeyLenOnServer(in, 0);
1059     ASSERT_NE(res, HC_SUCCESS);
1060     (void)AddIntToJson(payload, FIELD_KEY_LENGTH, 1);
1061     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1062     res = GetAndCheckKeyLenOnServer(in, 0);
1063     ASSERT_NE(res, HC_SUCCESS);
1064     FreeJson(payload);
1065     FreeJson(in);
1066     res = GetAuthIdPeerFromPayload(nullptr, nullptr, nullptr);
1067     ASSERT_NE(res, HC_SUCCESS);
1068     in = CreateJson();
1069     payload = CreateJson();
1070     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1071     res = GetAuthIdPeerFromPayload(in, nullptr, nullptr);
1072     ASSERT_NE(res, HC_SUCCESS);
1073     FreeJson(payload);
1074     FreeJson(in);
1075     res = GetAndCheckAuthIdPeer(nullptr, nullptr, nullptr);
1076     ASSERT_NE(res, HC_SUCCESS);
1077     in = CreateJson();
1078     payload = CreateJson();
1079     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1080     res = GetAndCheckAuthIdPeer(in, nullptr, nullptr);
1081     ASSERT_NE(res, HC_SUCCESS);
1082     (void)AddStringToJson(payload, FIELD_PEER_AUTH_ID, "");
1083     (void)AddObjToJson(in, FIELD_PAYLOAD, payload);
1084     res = GetAndCheckAuthIdPeer(in, nullptr, nullptr);
1085     ASSERT_NE(res, HC_SUCCESS);
1086     FreeJson(payload);
1087     FreeJson(in);
1088     res = GetIdPeer(nullptr, nullptr, nullptr, nullptr);
1089     ASSERT_NE(res, HC_SUCCESS);
1090     in = CreateJson();
1091     (void)AddStringToJson(in, FIELD_PEER_AUTH_ID, "");
1092     res = GetIdPeer(in, FIELD_PEER_AUTH_ID, nullptr, nullptr);
1093     ASSERT_NE(res, HC_SUCCESS);
1094     FreeJson(in);
1095     res = GeneratePseudonymPskAlias(nullptr, nullptr, nullptr);
1096     ASSERT_NE(res, HC_SUCCESS);
1097 }
1098 
1099 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest024, TestSize.Level0)
1100 {
1101     // das_task_common.c interface test
1102     Uint8Buff serviceTypeBuff = { (uint8_t *)TEST_GROUP_ID, 0 };
1103     Uint8Buff authIdBuff = { (uint8_t *)TEST_AUTH_ID, 0 };
1104     uint8_t outKeyAliasVal[256] = { 0 };
1105     Uint8Buff outKeyAliasBuff = { outKeyAliasVal, 0 };
1106     int32_t res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1107     ASSERT_NE(res, HC_SUCCESS);
1108     serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1109     res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1110     ASSERT_NE(res, HC_SUCCESS);
1111     authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1112     res = GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1113     ASSERT_NE(res, HC_SUCCESS);
1114     outKeyAliasBuff.length = 256;
1115     serviceTypeBuff.length = SERVICE_TYPE_MAX_LEN + 1;
1116     (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1117     serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1118     authIdBuff.length = AUTH_ID_MAX_LEN + 1;
1119     (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1120     authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1121     (void)GeneratePseudonymPskAlias(&serviceTypeBuff, &authIdBuff, &outKeyAliasBuff);
1122     Uint8Buff pkgNameBuff = { (uint8_t *)TEST_APP_ID, 0 };
1123     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1124     pkgNameBuff.length = HcStrlen(TEST_APP_ID);
1125     serviceTypeBuff.length = 0;
1126     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1127     serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1128     authIdBuff.length = 0;
1129     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1130     authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1131     outKeyAliasBuff.length = 0;
1132     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1133     outKeyAliasBuff.length = 256;
1134     pkgNameBuff.length = PACKAGE_NAME_MAX_LEN + 1;
1135     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1136     pkgNameBuff.length = HcStrlen(TEST_APP_ID);
1137     serviceTypeBuff.length = SERVICE_TYPE_MAX_LEN + 1;
1138     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1139     serviceTypeBuff.length = HcStrlen(TEST_GROUP_ID);
1140     authIdBuff.length = AUTH_ID_MAX_LEN + 1;
1141     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_ACCESSOR_PK, &authIdBuff, &outKeyAliasBuff);
1142     authIdBuff.length = HcStrlen(TEST_AUTH_ID);
1143     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_TYPE_END, &authIdBuff, &outKeyAliasBuff);
1144     (void)GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_PSK, &authIdBuff, &outKeyAliasBuff);
1145     res = GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, KEY_ALIAS_AUTH_TOKEN, &authIdBuff, &outKeyAliasBuff);
1146     ASSERT_NE(res, HC_SUCCESS);
1147 }
1148 
1149 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest025, TestSize.Level0)
1150 {
1151     // das_version_util.c interface test
1152     VersionStruct version = { 0 };
1153     PakeAlgType type = GetSupportedPakeAlg(&version, PAKE_V2);
1154     type = GetSupportedPakeAlg(&version, ISO);
1155     ProtocolType protocolType = GetPrototolType(&version, CODE_NULL);
1156     ASSERT_EQ(protocolType, PROTOCOL_TYPE_NONE);
1157     version.first = 1;
1158     protocolType = GetPrototolType(&version, AUTHENTICATE);
1159     ASSERT_EQ(protocolType, PROTOCOL_TYPE_NONE);
1160     protocolType = GetPrototolType(&version, OP_BIND);
1161     ASSERT_EQ(protocolType, PAKE_V1);
1162     VersionStruct versionSelf = { 0 };
1163     int32_t res = NegotiateVersion(nullptr, &version, &versionSelf);
1164     ASSERT_EQ(res, HC_SUCCESS);
1165     version.first = 0;
1166     res = NegotiateVersion(nullptr, &version, &versionSelf);
1167     ASSERT_NE(res, HC_SUCCESS);
1168     res = GetSingleVersionFromJson(nullptr, nullptr);
1169     ASSERT_NE(res, HC_SUCCESS);
1170     CJson *jsonObj = CreateJson();
1171     res = GetSingleVersionFromJson(jsonObj, nullptr);
1172     ASSERT_NE(res, HC_SUCCESS);
1173     res = GetSingleVersionFromJson(jsonObj, &version);
1174     ASSERT_NE(res, HC_SUCCESS);
1175     (void)AddStringToJson(jsonObj, FIELD_GROUP_AND_MODULE_VERSION, "123");
1176     res = GetSingleVersionFromJson(jsonObj, &version);
1177     ASSERT_EQ(res, HC_SUCCESS);
1178     (void)AddStringToJson(jsonObj, FIELD_GROUP_AND_MODULE_VERSION, "1.2.3");
1179     res = GetSingleVersionFromJson(jsonObj, &version);
1180     ASSERT_EQ(res, HC_SUCCESS);
1181 }
1182 
1183 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest026, TestSize.Level0)
1184 {
1185     // pake_v1_protocol_common.c interface test
1186     DestroyPakeV1BaseParams(nullptr);
1187     int32_t res = InitPakeV1BaseParams(DEFAULT_OS_ACCOUNT, nullptr);
1188     ASSERT_NE(res, HC_SUCCESS);
1189     res = ClientConfirmPakeV1Protocol(nullptr);
1190     ASSERT_NE(res, HC_SUCCESS);
1191     PakeBaseParams *params = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
1192     params->loader = GetLoaderInstance();
1193     res = ClientConfirmPakeV1Protocol(params);
1194     ASSERT_NE(res, HC_SUCCESS);
1195     res = ClientVerifyConfirmPakeV1Protocol(nullptr);
1196     ASSERT_NE(res, HC_SUCCESS);
1197     res = ClientVerifyConfirmPakeV1Protocol(params);
1198     ASSERT_NE(res, HC_SUCCESS);
1199     res = ServerResponsePakeV1Protocol(nullptr);
1200     ASSERT_NE(res, HC_SUCCESS);
1201     res = ServerResponsePakeV1Protocol(params);
1202     ASSERT_NE(res, HC_SUCCESS);
1203     res = ServerConfirmPakeV1Protocol(nullptr);
1204     ASSERT_NE(res, HC_SUCCESS);
1205     res = ServerConfirmPakeV1Protocol(params);
1206     ASSERT_NE(res, HC_SUCCESS);
1207     HcFree(params);
1208 }
1209 
1210 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest027, TestSize.Level0)
1211 {
1212     // huks_adapter.c interface test
1213     const AlgLoader *loader = GetLoaderInstance();
1214     ASSERT_NE(loader, nullptr);
1215     int32_t res = loader->importSymmetricKey(nullptr, nullptr, KEY_PURPOSE_SIGN_VERIFY, nullptr);
1216     ASSERT_NE(res, HC_SUCCESS);
1217     bool ret = loader->checkDlPublicKey(nullptr, nullptr);
1218     ASSERT_EQ(ret, false);
1219     Uint8Buff key = { 0 };
1220     ret = loader->checkDlPublicKey(&key, nullptr);
1221     ASSERT_EQ(ret, false);
1222     uint8_t keyVal[256] = { 0 };
1223     key.val = keyVal;
1224     key.length = 256;
1225     ret = loader->checkDlPublicKey(&key, nullptr);
1226     ASSERT_EQ(ret, false);
1227     ret = loader->checkDlPublicKey(&key, "TestPrimeHex");
1228     ASSERT_EQ(ret, false);
1229     res = loader->bigNumCompare(nullptr, nullptr);
1230     ASSERT_EQ(res, HC_SUCCESS);
1231     Uint8Buff aBuff = { 0 };
1232     Uint8Buff bBuff = { 0 };
1233     res = loader->bigNumCompare(&aBuff, &bBuff);
1234     ASSERT_EQ(res, HC_SUCCESS);
1235     res = loader->sign(nullptr, nullptr, ED25519, nullptr);
1236     ASSERT_NE(res, HC_SUCCESS);
1237     res = loader->generateKeyPair(ED25519, nullptr, nullptr);
1238     ASSERT_NE(res, HC_SUCCESS);
1239     Uint8Buff outPrivKey = { 0 };
1240     res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1241     ASSERT_NE(res, HC_SUCCESS);
1242     uint8_t outPrivKeyVal[256] = { 0 };
1243     outPrivKey.val = outPrivKeyVal;
1244     res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1245     ASSERT_NE(res, HC_SUCCESS);
1246     outPrivKey.length = 256;
1247     res = loader->generateKeyPair(ED25519, &outPrivKey, nullptr);
1248     ASSERT_NE(res, HC_SUCCESS);
1249     Uint8Buff outPubKey = { 0 };
1250     res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1251     ASSERT_NE(res, HC_SUCCESS);
1252     uint8_t outPubKeyVal[256] = { 0 };
1253     outPubKey.val = outPubKeyVal;
1254     res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1255     ASSERT_NE(res, HC_SUCCESS);
1256     outPubKey.length = 128;
1257     res = loader->generateKeyPair(ED25519, &outPrivKey, &outPubKey);
1258     ASSERT_NE(res, HC_SUCCESS);
1259 }
1260 
1261 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest028, TestSize.Level0)
1262 {
1263     // dev_session_util.c interface test
1264     int32_t res = AddPkInfoWithPdid(nullptr, nullptr, nullptr);
1265     ASSERT_NE(res, HC_SUCCESS);
1266     CJson *context = CreateJson();
1267     res = AddPkInfoWithPdid(context, nullptr, nullptr);
1268     ASSERT_NE(res, HC_SUCCESS);
1269     CJson *credJson = CreateJson();
1270     res = AddPkInfoWithPdid(context, credJson, nullptr);
1271     ASSERT_NE(res, HC_SUCCESS);
1272     res = AddPkInfoWithPdid(context, credJson, "TestRealPkInfo");
1273     ASSERT_NE(res, HC_SUCCESS);
1274     CJson *realPkInfoJson = CreateJson();
1275     (void)AddStringToJson(realPkInfoJson, FIELD_USER_ID, TEST_GROUP_ID);
1276     (void)AddStringToJson(realPkInfoJson, FIELD_DEVICE_ID, TEST_AUTH_ID);
1277     char *realPkInfoStr = PackJsonToString(realPkInfoJson);
1278     FreeJson(realPkInfoJson);
1279     res = AddPkInfoWithPdid(context, credJson, realPkInfoStr);
1280     FreeJsonString(realPkInfoStr);
1281     ASSERT_NE(res, HC_SUCCESS);
1282     FreeJson(context);
1283     FreeJson(credJson);
1284     res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, nullptr, nullptr, nullptr);
1285     ASSERT_NE(res, HC_SUCCESS);
1286     credJson = CreateJson();
1287     (void)AddStringToJson(credJson, FIELD_PK_INFO, "TestPkInfo");
1288     res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, credJson, nullptr, nullptr);
1289     ASSERT_NE(res, HC_SUCCESS);
1290     CJson *pkInfoJson = CreateJson();
1291     (void)AddStringToJson(pkInfoJson, FIELD_USER_ID, TEST_GROUP_ID);
1292     (void)AddStringToJson(pkInfoJson, FIELD_DEVICE_ID, TEST_AUTH_ID);
1293     char *pkInfoStr = PackJsonToString(pkInfoJson);
1294     FreeJson(pkInfoJson);
1295     (void)AddStringToJson(credJson, FIELD_PK_INFO, pkInfoStr);
1296     FreeJsonString(pkInfoStr);
1297     res = GetRealPkInfoStr(DEFAULT_OS_ACCOUNT, credJson, nullptr, nullptr);
1298     ASSERT_NE(res, HC_SUCCESS);
1299     FreeJson(credJson);
1300 }
1301 
1302 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest029, TestSize.Level0)
1303 {
1304     // pake_v2_protocol_common.c interface test
1305     DestroyPakeV2BaseParams(nullptr);
1306     int32_t res = ServerConfirmPakeV2Protocol(nullptr);
1307     ASSERT_NE(res, HC_SUCCESS);
1308     PakeBaseParams *params = (PakeBaseParams *)HcMalloc(sizeof(PakeBaseParams), 0);
1309     params->loader = GetLoaderInstance();
1310     res = ServerConfirmPakeV2Protocol(params);
1311     ASSERT_NE(res, HC_SUCCESS);
1312     res = ServerResponsePakeV2Protocol(nullptr);
1313     ASSERT_NE(res, HC_SUCCESS);
1314     res = ServerResponsePakeV2Protocol(params);
1315     ASSERT_NE(res, HC_SUCCESS);
1316     res = ClientVerifyConfirmPakeV2Protocol(nullptr);
1317     ASSERT_NE(res, HC_SUCCESS);
1318     res = ClientVerifyConfirmPakeV2Protocol(params);
1319     ASSERT_NE(res, HC_SUCCESS);
1320     res = ClientConfirmPakeV2Protocol(nullptr);
1321     ASSERT_NE(res, HC_SUCCESS);
1322     res = ClientConfirmPakeV2Protocol(params);
1323     ASSERT_NE(res, HC_SUCCESS);
1324     res = InitPakeV2BaseParams(DEFAULT_OS_ACCOUNT, nullptr);
1325     ASSERT_NE(res, HC_SUCCESS);
1326     HcFree(params);
1327 }
1328 
1329 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest030, TestSize.Level0)
1330 {
1331     // iso_task_common.c interface test
1332     IsoParams *params = (IsoParams *)HcMalloc(sizeof(IsoParams), 0);
1333     int res = GeneratePsk(nullptr, params);
1334     ASSERT_NE(res, HC_SUCCESS);
1335     res = GenerateKeyAliasInIso(nullptr, nullptr, 0, false);
1336     ASSERT_NE(res, HC_SUCCESS);
1337     res = GenerateKeyAliasInIso(params, nullptr, 0, false);
1338     ASSERT_NE(res, HC_SUCCESS);
1339     uint8_t keyAliasVal[256] = { 0 };
1340     res = GenerateKeyAliasInIso(params, keyAliasVal, 0, false);
1341     ASSERT_NE(res, HC_SUCCESS);
1342     params->packageName = (char *)HcMalloc(HcStrlen(TEST_APP_ID) + 1, 0);
1343     (void)memcpy_s(params->packageName, HcStrlen(TEST_APP_ID) + 1, TEST_APP_ID, HcStrlen(TEST_APP_ID));
1344     params->serviceType = (char *)HcMalloc(HcStrlen(TEST_GROUP_ID) + 1, 0);
1345     (void)memcpy_s(params->serviceType, HcStrlen(TEST_GROUP_ID) + 1, TEST_GROUP_ID, HcStrlen(TEST_GROUP_ID));
1346     res = GenerateKeyAliasInIso(params, keyAliasVal, 256, false);
1347     ASSERT_NE(res, HC_SUCCESS);
1348     res = InitIsoParams(params, nullptr);
1349     ASSERT_NE(res, HC_SUCCESS);
1350     CJson *in = CreateJson();
1351     (void)AddIntToJson(in, FIELD_OPERATION_CODE, CODE_NULL);
1352     res = InitIsoParams(params, in);
1353     ASSERT_NE(res, HC_SUCCESS);
1354     (void)AddIntToJson(in, FIELD_OPERATION_CODE, AUTHENTICATE);
1355     res = InitIsoParams(params, in);
1356     ASSERT_NE(res, HC_SUCCESS);
1357     (void)AddBoolToJson(in, FIELD_IS_CLIENT, true);
1358     res = InitIsoParams(params, in);
1359     ASSERT_NE(res, HC_SUCCESS);
1360     DestroyIsoParams(nullptr);
1361     HcFree(params);
1362 }
1363 
1364 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest031, TestSize.Level0)
1365 {
1366     // das_task_common.c interface test
1367     int res = ServerProtocolMessageOut(nullptr, 0, 0);
1368     ASSERT_EQ(res, HC_SUCCESS);
1369     CJson *out = CreateJson();
1370     CJson *sendToPeer = CreateJson();
1371     (void)AddObjToJson(out, FIELD_SEND_TO_PEER, sendToPeer);
1372     res = ServerProtocolMessageOut(out, CODE_NULL, 0);
1373     ASSERT_NE(res, HC_SUCCESS);
1374     res = ClientProtocolMessageOut(nullptr, 0, 0);
1375     ASSERT_EQ(res, HC_SUCCESS);
1376     res = ClientProtocolMessageOut(out, CODE_NULL, 0);
1377     ASSERT_NE(res, HC_SUCCESS);
1378     FreeJson(sendToPeer);
1379     FreeJson(out);
1380     CJson *in = CreateJson();
1381     (void)AddIntToJson(in, FIELD_MESSAGE, ERR_MESSAGE);
1382     uint32_t msg = ProtocolMessageIn(in);
1383     ASSERT_EQ(msg, ERR_MESSAGE);
1384     FreeJson(in);
1385 }
1386 
1387 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest032, TestSize.Level0)
1388 {
1389     // dev_session_util.c interface test
1390     int32_t res = CheckPeerPkInfoForPdid(nullptr, nullptr);
1391     ASSERT_NE(res, HC_SUCCESS);
1392     CJson *context = CreateJson();
1393     (void)AddIntToJson(context, FIELD_OS_ACCOUNT_ID, DEFAULT_OS_ACCOUNT);
1394     res = CheckPeerPkInfoForPdid(context, nullptr);
1395     ASSERT_NE(res, HC_SUCCESS);
1396     CJson *inputDataJson = CreateJson();
1397     (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, "TestPkInfo");
1398     res = CheckPeerPkInfoForPdid(context, inputDataJson);
1399     ASSERT_NE(res, HC_SUCCESS);
1400     CJson *pkInfoJson = CreateJson();
1401     (void)AddStringToJson(pkInfoJson, FIELD_PSEUDONYM_ID, "TestPseudonymId");
1402     char *pkInfoStr = PackJsonToString(pkInfoJson);
1403     FreeJson(pkInfoJson);
1404     (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, pkInfoStr);
1405     FreeJsonString(pkInfoStr);
1406     res = CheckPeerPkInfoForPdid(context, inputDataJson);
1407     ASSERT_EQ(res, HC_SUCCESS);
1408     FreeJson(context);
1409     FreeJson(inputDataJson);
1410     res = SetPeerInfoToContext(nullptr, nullptr);
1411     ASSERT_NE(res, HC_SUCCESS);
1412     inputDataJson = CreateJson();
1413     (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, "TestPkInfo");
1414     res = SetPeerInfoToContext(nullptr, inputDataJson);
1415     ASSERT_NE(res, HC_SUCCESS);
1416     pkInfoJson = CreateJson();
1417     pkInfoStr = PackJsonToString(pkInfoJson);
1418     FreeJson(pkInfoJson);
1419     (void)AddStringToJson(inputDataJson, FIELD_PK_INFO, pkInfoStr);
1420     FreeJsonString(pkInfoStr);
1421     res = SetPeerInfoToContext(nullptr, inputDataJson);
1422     ASSERT_NE(res, HC_SUCCESS);
1423     FreeJson(inputDataJson);
1424 }
1425 
1426 HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest033, TestSize.Level0)
1427 {
1428     // huks_adapter.c interface test
1429     const AlgLoader *loader = GetLoaderInstance();
1430     ASSERT_NE(loader, nullptr);
1431     int32_t res = loader->agreeSharedSecretWithStorage(nullptr, nullptr, X25519, 0, nullptr);
1432     ASSERT_NE(res, HC_SUCCESS);
1433     res = loader->getKeyExtInfo(nullptr, nullptr);
1434     ASSERT_NE(res, HC_SUCCESS);
1435     KeyParams keyParams = { { nullptr, 0, true }, true, DEFAULT_OS_ACCOUNT };
1436     res = loader->getKeyExtInfo(&keyParams, nullptr);
1437     uint8_t keyAliasVal[256] = { 0 };
1438     keyParams.keyBuff.key = keyAliasVal;
1439     keyParams.keyBuff.keyLen = 256;
1440     res = loader->getKeyExtInfo(&keyParams, nullptr);
1441     ASSERT_NE(res, HC_SUCCESS);
1442     Uint8Buff outExtInfo = { 0 };
1443     res = loader->getKeyExtInfo(&keyParams, &outExtInfo);
1444     ASSERT_NE(res, HC_SUCCESS);
1445     keyParams.isDeStorage = false;
1446     res = loader->getKeyExtInfo(&keyParams, &outExtInfo);
1447     ASSERT_NE(res, HC_SUCCESS);
1448     res = loader->computePseudonymPsk(nullptr, nullptr, nullptr, nullptr);
1449     ASSERT_NE(res, HC_SUCCESS);
1450     KeyParams params = { { 0 }, false, DEFAULT_OS_ACCOUNT };
1451     uint8_t keyValue[256] = { 0 };
1452     params.keyBuff.key = keyValue;
1453     params.keyBuff.keyLen = 256;
1454     params.keyBuff.isAlias = true;
1455     params.isDeStorage = true;
1456     res = loader->computePseudonymPsk(&params, nullptr, nullptr, nullptr);
1457     ASSERT_NE(res, HC_SUCCESS);
1458     uint8_t pskAliasVal[256] = { 0 };
1459     Uint8Buff pskAlias = { pskAliasVal, 256 };
1460     uint8_t outPskVal[32] = { 0 };
1461     Uint8Buff outPsk = { outPskVal, 32 };
1462     res = loader->computePseudonymPsk(&params, &pskAlias, nullptr, &outPsk);
1463     ASSERT_NE(res, HC_SUCCESS);
1464     Uint8Buff extInfo = { 0 };
1465     res = loader->computePseudonymPsk(&params, &pskAlias, &extInfo, &outPsk);
1466     ASSERT_NE(res, HC_SUCCESS);
1467     res = loader->computeHkdf(nullptr, nullptr, nullptr, nullptr);
1468     ASSERT_NE(res, HC_SUCCESS);
1469     res = loader->computeHmacWithThreeStage(nullptr, nullptr, nullptr);
1470     ASSERT_NE(res, HC_SUCCESS);
1471 }
1472 } // namespace