1 /*
2 * Copyright (c) 2022-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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <sys/time.h>
21
22 #include "auth_connection.c"
23 #include "auth_connection.h"
24 #include "auth_device.c"
25 #include "auth_interface.c"
26 #include "auth_interface.h"
27 #include "auth_lane.c"
28 #include "auth_log.h"
29 #include "auth_manager.c"
30 #include "auth_manager.h"
31 #include "auth_session_fsm.c"
32 #include "auth_session_fsm.h"
33 #include "auth_session_key.c"
34 #include "auth_session_key.h"
35 #include "auth_tcp_connection_mock.h"
36 #include "auth_common_mock.h"
37 #include "lnn_ctrl_lane.h"
38 #include "lnn_lane_interface.h"
39 #include "softbus_adapter_json.h"
40 #include "softbus_error_code.h"
41 #include "softbus_socket.h"
42
43 namespace OHOS {
44 using namespace testing::ext;
45 using namespace testing;
46 constexpr uint32_t TEST_DATA_LEN = 30;
47 constexpr uint32_t MSG_LEN = 50;
48 constexpr char NETWORK_ID[] = "testnetworkid123";
49
50 class AuthOtherTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp();
55 void TearDown();
56 };
57
SetUpTestCase()58 void AuthOtherTest::SetUpTestCase()
59 {
60 int32_t ret = AuthCommonInit();
61 EXPECT_TRUE(ret == SOFTBUS_OK);
62 }
63
TearDownTestCase()64 void AuthOtherTest::TearDownTestCase()
65 {
66 AuthCommonDeinit();
67 }
68
SetUp()69 void AuthOtherTest::SetUp() { }
70
TearDown()71 void AuthOtherTest::TearDown() { }
72
OnConnectResultTest(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)73 void OnConnectResultTest(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo)
74 {
75 (void)requestId;
76 (void)connId;
77 (void)result;
78 (void)connInfo;
79 }
80
OnDisconnectedTest(uint64_t connId,const AuthConnInfo * connInfo)81 void OnDisconnectedTest(uint64_t connId, const AuthConnInfo *connInfo)
82 {
83 (void)connId;
84 (void)connInfo;
85 }
86
OnDataReceivedTest(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)87 void OnDataReceivedTest(
88 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
89 {
90 (void)connId;
91 (void)connInfo;
92 (void)fromServer;
93 (void)head;
94 (void)data;
95 }
96
OnDeviceNotTrustedTest(const char * udid)97 void OnDeviceNotTrustedTest(const char *udid)
98 {
99 (void)udid;
100 }
101
OnDeviceVerifyPassTest(AuthHandle authHandle,const NodeInfo * info)102 void OnDeviceVerifyPassTest(AuthHandle authHandle, const NodeInfo *info)
103 {
104 (void)authHandle;
105 (void)info;
106 }
107
OnDeviceDisconnectTest(int64_t authId)108 void OnDeviceDisconnectTest(int64_t authId)
109 {
110 (void)authId;
111 }
112
OnGroupCreatedTest(const char * groupId,int32_t groupType)113 void OnGroupCreatedTest(const char *groupId, int32_t groupType)
114 {
115 (void)groupId;
116 (void)groupType;
117 }
118
OnGroupDeletedTest(const char * groupId)119 void OnGroupDeletedTest(const char *groupId)
120 {
121 (void)groupId;
122 }
123
124 /*
125 * @tc.name: ADD_CONN_REQUEST_TEST_001
126 * @tc.desc: add conn request test
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(AuthOtherTest, ADD_CONN_REQUEST_TEST_001, TestSize.Level1)
131 {
132 AuthConnInfo connInfo;
133 uint32_t requestId = 0;
134 int32_t fd = 0;
135
136 int32_t ret = AddConnRequest(&connInfo, requestId, fd);
137 EXPECT_TRUE(ret == SOFTBUS_OK);
138 ConnRequest *item = FindConnRequestByRequestId(requestId);
139 EXPECT_TRUE(item != nullptr);
140 DelConnRequest(nullptr);
141 DelConnRequest(item);
142 }
143
144 /*
145 * @tc.name: REMOVE_FUNC_TEST_001
146 * @tc.desc: remove func test
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(AuthOtherTest, REMOVE_FUNC_TEST_001, TestSize.Level1)
151 {
152 uint32_t obj = 1;
153 uint32_t param = 1;
154
155 int32_t ret = RemoveFunc(nullptr, static_cast<void *>(¶m));
156 EXPECT_NE(ret, SOFTBUS_OK);
157 ret = RemoveFunc(static_cast<void *>(&obj), nullptr);
158 EXPECT_NE(ret, SOFTBUS_OK);
159 ret = RemoveFunc(static_cast<void *>(&obj), static_cast<void *>(¶m));
160 EXPECT_TRUE(ret == SOFTBUS_OK);
161 }
162
163 /*
164 * @tc.name: CHECK_ACTIVE_AUTH_CONNECTION_TEST_001
165 * @tc.desc: check active auth connection test
166 * @tc.type: FUNC
167 * @tc.require:
168 */
169 HWTEST_F(AuthOtherTest, CHECK_ACTIVE_AUTH_CONNECTION_TEST_001, TestSize.Level1)
170 {
171 AuthConnInfo connInfo;
172
173 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
174 bool ret = CheckActiveAuthConnection(nullptr);
175 EXPECT_TRUE(ret == false);
176 ret = CheckActiveAuthConnection(&connInfo);
177 EXPECT_TRUE(ret == false);
178 }
179
180 /*
181 * @tc.name: AUTH_GET_META_TYPE_TEST_001
182 * @tc.desc: auth get meta type test
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(AuthOtherTest, AUTH_GET_META_TYPE_TEST_001, TestSize.Level1)
187 {
188 int64_t authId = 0;
189 bool isMetaAuth = false;
190
191 int32_t ret = AuthGetMetaType(authId, nullptr);
192 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
193 ret = AuthGetMetaType(authId, &isMetaAuth);
194 EXPECT_TRUE(ret == SOFTBUS_OK);
195 }
196
197 /*
198 * @tc.name: REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001
199 * @tc.desc: remove auth manager by auth id test
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(AuthOtherTest, REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001, TestSize.Level1)
204 {
205 int64_t authSeq = 0;
206 AuthSessionInfo info;
207 AuthConnInfo connInfo;
208 const char *udid = "000";
209 uint64_t connId = 0;
210 uint64_t errConnId = 1;
211 const char *ip = "192.168.12.1";
212
213 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
214 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
215 (void)strcpy_s(info.udid, UDID_BUF_LEN, udid);
216 (void)strcpy_s(info.uuid, UUID_BUF_LEN, udid);
217 info.connId = 0;
218 info.isServer = true;
219 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
220 ListInit(&g_authServerList);
221 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
222 AuthManager *auth = NewAuthManager(authSeq, &info);
223 EXPECT_TRUE(auth != nullptr);
224 int64_t ret = GetAuthIdByConnId(errConnId, true);
225 EXPECT_TRUE(ret == AUTH_INVALID_ID);
226 ret = GetAuthIdByConnId(connId, true);
227 EXPECT_TRUE(ret != AUTH_INVALID_ID);
228 connInfo.type = AUTH_LINK_TYPE_WIFI;
229 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
230 ret = GetActiveAuthIdByConnInfo(&connInfo, false);
231 EXPECT_TRUE(ret == AUTH_INVALID_ID);
232 AuthHandle authHandle = { .authId = authSeq, .type = AUTH_LINK_TYPE_WIFI };
233 RemoveAuthManagerByAuthId(authHandle);
234 RemoveAuthManagerByConnInfo(&connInfo, true);
235 RemoveNotPassedAuthManagerByUdid(udid);
236 }
237
238 /*
239 * @tc.name: NOTIFY_DEVICE_VERIFY_PASSED_TEST_001
240 * @tc.desc: notify device verify passed test
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(AuthOtherTest, NOTIFY_DEVICE_VERIFY_PASSED_TEST_001, TestSize.Level1)
245 {
246 int64_t authId = 0;
247 int64_t errAuthId = 1;
248 NodeInfo nodeInfo;
249 AuthSessionInfo info;
250
251 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
252 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
253 info.isServer = true;
254 info.connInfo.type = AUTH_LINK_TYPE_BLE;
255 AuthManager *auth = NewAuthManager(authId, &info);
256 EXPECT_TRUE(auth != nullptr);
257 AuthHandle errHandle = { .authId = errAuthId, .type = AUTH_LINK_TYPE_BLE };
258 AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_BLE };
259 AuthNotifyDeviceVerifyPassed(errHandle, &nodeInfo);
260 g_verifyListener.onDeviceVerifyPass = nullptr;
261 AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
262 g_verifyListener.onDeviceVerifyPass = OnDeviceVerifyPassTest, AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
263 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
264 }
265
266 /*
267 * @tc.name: AUTH_MANAGER_SET_AUTH_PASSED_TEST_001
268 * @tc.desc: auth manager set auth passed test
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_AUTH_PASSED_TEST_001, TestSize.Level1)
273 {
274 int64_t authSeq = 0;
275 int64_t errAuthId = 1;
276 AuthSessionInfo info;
277 int32_t reason = 0;
278
279 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
280 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
281 AuthManager *auth = NewAuthManager(authSeq, &info);
282 EXPECT_TRUE(auth != nullptr);
283 AuthManagerSetAuthPassed(authSeq, nullptr);
284 AuthManagerSetAuthPassed(errAuthId, &info);
285 AuthManagerSetAuthPassed(authSeq, &info);
286 AuthManagerSetAuthFailed(errAuthId, &info, reason);
287 AuthManagerSetAuthFailed(authSeq, &info, reason);
288 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
289 }
290
291 /*
292 * @tc.name: HANDLE_CONNECTION_DATA_TEST_001
293 * @tc.desc: handle connection data test
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(AuthOtherTest, HANDLE_CONNECTION_DATA_TEST_001, TestSize.Level1)
298 {
299 uint64_t connId = 0;
300 int64_t authId = 0;
301 AuthConnInfo connInfo;
302 AuthDataHead head;
303 AuthSessionInfo info;
304 const uint8_t *data = nullptr;
305 bool fromServer = true;
306 const char *ip = "192.168.12.1";
307
308 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
309 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
310 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
311 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
312 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
313 AuthManager *auth = NewAuthManager(authId, &info);
314 EXPECT_TRUE(auth != nullptr);
315 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
316 connInfo.type = AUTH_LINK_TYPE_WIFI;
317 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
318 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
319 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
320 }
321
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)322 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
323 {
324 AUTH_LOGI(
325 AUTH_TEST, "OnConnOpenedTest: requestId=%{public}d, authId=%{public}" PRId64 ".", requestId, authHandle.authId);
326 }
327
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)328 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
329 {
330 AUTH_LOGI(AUTH_TEST, "OnConnOpenFailedTest: requestId=%{public}d, reason=%{public}d.", requestId, reason);
331 }
332
333 /*
334 * @tc.name: AUTH_DEVICE_OPEN_CONN_TEST_001
335 * @tc.desc: auth device open conn test
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(AuthOtherTest, AUTH_DEVICE_OPEN_CONN_TEST_001, TestSize.Level1)
340 {
341 AuthSessionInfo info;
342 AuthConnInfo connInfo;
343 uint32_t requestId = 0;
344 int64_t authId = 0;
345 const char *ip = "192.168.12.1";
346 AuthConnCallback cb = {
347 .onConnOpened = OnConnOpenedTest,
348 .onConnOpenFailed = OnConnOpenFailedTest,
349 };
350
351 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
352 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
353 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
354 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
355 AuthManager *auth = NewAuthManager(authId, &info);
356 EXPECT_TRUE(auth != nullptr);
357 connInfo.type = AUTH_LINK_TYPE_WIFI;
358 int32_t ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
359 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
360 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
361 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
362 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
363 connInfo.type = AUTH_LINK_TYPE_BR;
364 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
365 EXPECT_TRUE(ret != SOFTBUS_OK);
366 }
367
368 /*
369 * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_001
370 * @tc.desc: update auth request conn info test
371 * @tc.type: FUNC
372 * @tc.require:
373 */
374 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_001, TestSize.Level1)
375 {
376 AuthConnInfo connInfo;
377 AuthRequest request;
378
379 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
380 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
381 int32_t ret = FindAuthRequestByConnInfo(&connInfo, &request);
382 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
383 uint32_t requestId = 1;
384 ret = GetAuthRequestNoLock(requestId, &request);
385 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
386 ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
387 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
388 int32_t result = 1;
389 int64_t authId = 10;
390 PerformAuthConnCallback(requestId, result, authId);
391 AuthConnCallback cb = {
392 .onConnOpened = OnConnOpenedTest,
393 .onConnOpenFailed = OnConnOpenFailedTest,
394 };
395 request.requestId = 1;
396 request.connInfo.type = AUTH_LINK_TYPE_BLE;
397 request.connCb = cb;
398 ret = AddAuthRequest(&request);
399 EXPECT_TRUE(ret != 0);
400 ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
401 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
402 PerformAuthConnCallback(request.requestId, SOFTBUS_OK, authId);
403 PerformAuthConnCallback(request.requestId, SOFTBUS_NOT_FIND, authId);
404 request.connInfo.type = AUTH_LINK_TYPE_WIFI;
405 ret = AddAuthRequest(&request);
406 EXPECT_TRUE(ret != 0);
407 DelAuthRequest(request.requestId);
408 }
409
410 /*
411 * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_002
412 * @tc.desc: update auth request conn info test
413 * @tc.type: FUNC
414 * @tc.require:
415 */
416 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_002, TestSize.Level1)
417 {
418 AuthConnInfo connInfo;
419 AuthRequest request;
420 int64_t authId = 10;
421 uint32_t requestId = 1;
422 AuthConnCallback connCb = {
423 .onConnOpened = nullptr,
424 .onConnOpenFailed = nullptr,
425 };
426
427 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
428 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
429 request.requestId = requestId;
430 request.connInfo.type = AUTH_LINK_TYPE_BLE;
431 request.connCb = connCb;
432 int32_t ret = AddAuthRequest(&request);
433 EXPECT_TRUE(ret != 0);
434 PerformAuthConnCallback(requestId, SOFTBUS_OK, authId);
435 connInfo.type = AUTH_LINK_TYPE_BLE;
436 request.requestId = 2;
437 ret = FindAndDelAuthRequestByConnInfo(request.requestId, &connInfo);
438 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
439 ret = AddAuthRequest(&request);
440 EXPECT_TRUE(ret != 0);
441 DelAuthRequest(requestId);
442 DelAuthRequest(request.requestId);
443 }
444
445 /*
446 * @tc.name: RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001
447 * @tc.desc: rmove update session key func test
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(AuthOtherTest, RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001, TestSize.Level1)
452 {
453 int64_t authId = 1;
454 int64_t para = 0;
455 int32_t ret = RemoveUpdateSessionKeyFunc(nullptr, nullptr);
456 EXPECT_NE(ret, SOFTBUS_OK);
457 ret = RemoveUpdateSessionKeyFunc(&authId, nullptr);
458 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
459 ret = RemoveUpdateSessionKeyFunc(&authId, ¶);
460 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
461 ret = RemoveUpdateSessionKeyFunc(&authId, &authId);
462 EXPECT_TRUE(ret == SOFTBUS_OK);
463 }
464
465 /*
466 * @tc.name: POST_CLOSE_ACK_MESSAGE_TEST_001
467 * @tc.desc: post close ack message test
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(AuthOtherTest, POST_CLOSE_ACK_MESSAGE_TEST_001, TestSize.Level1)
472 {
473 int64_t authSeq = 0;
474 AuthSessionInfo info;
475 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
476 int32_t ret = PostCloseAckMessage(authSeq, nullptr);
477 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
478 ret = PostCloseAckMessage(authSeq, &info);
479 EXPECT_TRUE(ret != SOFTBUS_OK);
480 }
481
482 /*
483 * @tc.name: PACK_AUTH_DATA_TEST_001
484 * @tc.desc: pack auth data test
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(AuthOtherTest, PACK_AUTH_DATA_TEST_001, TestSize.Level1)
489 {
490 AuthDataHead head;
491 uint8_t *buf = nullptr;
492 const uint8_t data[TEST_DATA_LEN] = { 0 };
493 uint32_t len = 32;
494
495 (void)memset_s(&head, sizeof(AuthDataHead), AUTH_CONN_DATA_HEAD_SIZE, sizeof(AuthDataHead));
496 int32_t ret = PackAuthData(&head, data, buf, len);
497 EXPECT_TRUE(ret != SOFTBUS_OK);
498 }
499
500 /*
501 * @tc.name: GET_CONN_SIDE_TYPE_TEST_001
502 * @tc.desc: get connside type test
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(AuthOtherTest, GET_CONN_SIDE_TYPE_TEST_001, TestSize.Level1)
507 {
508 AuthCommonInterfaceMock connMock;
509 EXPECT_CALL(connMock, ConnGetConnectionInfo).WillRepeatedly(Return(true));
510 uint64_t connId = 0;
511 connId = GetConnType(connId);
512 ConnSideType ret = GetConnSideType(connId);
513 EXPECT_EQ(ret, CONN_SIDE_ANY);
514 ret = GetConnSideType(0x1FFFFFFFF);
515 EXPECT_EQ(ret, CONN_SIDE_ANY);
516 ret = GetConnSideType(0x2FFFFFFFF);
517 EXPECT_EQ(ret, CONN_SIDE_ANY);
518 ret = GetConnSideType(0x3FFFFFFFF);
519 EXPECT_EQ(ret, CONN_SIDE_ANY);
520 ret = GetConnSideType(0x4FFFFFFFF);
521 EXPECT_EQ(ret, CONN_SIDE_ANY);
522 }
523
524 /*
525 * @tc.name: ON_COMM_DATA_RECEVIED_TEST_001
526 * @tc.desc: on comm data received test
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(AuthOtherTest, ON_COMM_DATA_RECEVIED_TEST_001, TestSize.Level1)
531 {
532 uint32_t connectionId = 0;
533 ConnModule moduleId = MODULE_DEVICE_AUTH;
534 int64_t seq = 0;
535 int32_t len = 0;
536 char *data = reinterpret_cast<char *>(malloc(1024));
537 ASSERT_NE(data, nullptr);
538 OnCommDataReceived(connectionId, moduleId, seq, data, len);
539
540 const int32_t SEND_DATA_SIZE_1KB = 1024;
541 const char *testData = "{\"data\":\"open session test!!!\"}";
542 len = 2;
543 moduleId = MODULE_CONNECTION;
544 int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1KB, testData, strlen(testData));
545 EXPECT_EQ(ret, SOFTBUS_OK);
546 OnCommDataReceived(connectionId, moduleId, seq, nullptr, len);
547 OnCommDataReceived(connectionId, moduleId, seq, data, len);
548
549 free(data);
550 }
551
552 /*
553 * @tc.name: IS_FLUSH_DEVICE_PACKET_TEST_001
554 * @tc.desc: is flush device packet test
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 HWTEST_F(AuthOtherTest, IS_FLUSH_DEVICE_PACKET_TEST_001, TestSize.Level1)
559 {
560 const char *sessionKeyStr = "www.test.com";
561 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
562 if (connInfo == nullptr) {
563 return;
564 }
565 (void)memset_s(connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
566 connInfo->type = AUTH_LINK_TYPE_BLE;
567
568 AuthDataHead *head = (AuthDataHead *)SoftBusCalloc(sizeof(AuthDataHead));
569 if (head == nullptr) {
570 return;
571 }
572 (void)memset_s(head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
573 head->len = strlen(sessionKeyStr);
574 const uint8_t data = { 0 };
575 bool isServer = false;
576 DeviceMessageParse messageParse = { 0 };
577 bool ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
578 EXPECT_TRUE(ret == false);
579 connInfo->type = AUTH_LINK_TYPE_WIFI;
580 ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
581 EXPECT_TRUE(ret == false);
582 SoftBusFree(head);
583 SoftBusFree(connInfo);
584 }
585
586 /*
587 * @tc.name: FSM_MSG_TYPE_TO_STR_TEST_001
588 * @tc.desc: fsm msg type to str test
589 * @tc.type: FUNC
590 * @tc.require:
591 */
592 HWTEST_F(AuthOtherTest, FSM_MSG_TYPE_TO_STR_TEST_001, TestSize.Level1)
593 {
594 int32_t type = FSM_MSG_UNKNOWN;
595 const char *str = "UNKNOWN MSG!!";
596 char *ret = FsmMsgTypeToStr(type);
597 EXPECT_EQ(ret, str);
598 type = -1;
599 ret = FsmMsgTypeToStr(type);
600 EXPECT_EQ(ret, str);
601 type = FSM_MSG_RECV_DEVICE_ID;
602 ret = FsmMsgTypeToStr(type);
603 const char *str1 = "RECV_DEVICE_ID";
604 EXPECT_EQ(ret, str1);
605 }
606
607 /*
608 * @tc.name: AUTH_MANAGER_SET_SESSION_KEY_TEST_001
609 * @tc.desc: fsm msg type to str test
610 * @tc.type: FUNC
611 * @tc.require:
612 */
613 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_SESSION_KEY_TEST_001, TestSize.Level1)
614 {
615 int64_t authSeq = 0;
616 AuthSessionInfo *info = (AuthSessionInfo *)SoftBusCalloc(sizeof(AuthSessionInfo));
617 if (info == nullptr) {
618 return;
619 }
620 info->requestId = 1;
621 info->isServer = false;
622 info->connInfo.type = AUTH_LINK_TYPE_WIFI;
623 SessionKey *sessionKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
624 if (sessionKey == nullptr) {
625 return;
626 }
627 AuthCommonInterfaceMock connMock;
628 EXPECT_CALL(connMock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_OK));
629 sessionKey->len = 0;
630 int32_t ret = AuthManagerSetSessionKey(authSeq, info, sessionKey, false, false);
631 EXPECT_TRUE(ret == SOFTBUS_OK);
632 ret = AuthManagerGetSessionKey(authSeq, info, sessionKey);
633 EXPECT_TRUE(ret != SOFTBUS_OK);
634 AuthManagerSetAuthPassed(authSeq, info);
635 AuthManagerSetAuthFinished(authSeq, info);
636 info->isServer = true;
637 info->connInfo.type = AUTH_LINK_TYPE_BLE;
638 AuthManagerSetAuthFinished(authSeq, info);
639 SoftBusFree(sessionKey);
640 SoftBusFree(info);
641 }
642
643 /*
644 * @tc.name: AUTH_DEVICE_CLOSE_CONN_TEST_001
645 * @tc.desc: fsm msg type to str test
646 * @tc.type: FUNC
647 * @tc.require:
648 */
649 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CLOSE_CONN_TEST_001, TestSize.Level1)
650 {
651 AuthHandle authHandle = { .authId = 111, .type = AUTH_LINK_TYPE_WIFI };
652 AuthDeviceCloseConn(authHandle);
653 AuthTransData *dataInfo = (AuthTransData *)SoftBusCalloc(sizeof(AuthTransData));
654 if (dataInfo == nullptr) {
655 return;
656 }
657 int32_t ret = AuthDevicePostTransData(authHandle, nullptr);
658 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
659 dataInfo->module = 1;
660 dataInfo->seq = 2;
661 dataInfo->flag = 0;
662 ret = AuthDevicePostTransData(authHandle, dataInfo);
663 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
664 SoftBusFree(dataInfo);
665 }
666
667 /*
668 * @tc.name: AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001
669 * @tc.desc: fsm msg type to str test
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(AuthOtherTest, AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001, TestSize.Level1)
674 {
675 const char *uuid = "";
676 int32_t ret = AuthDeviceGetPreferConnInfo(uuid, nullptr);
677 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
678 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
679 if (connInfo == nullptr) {
680 return;
681 }
682 ret = AuthDeviceGetPreferConnInfo(nullptr, connInfo);
683 connInfo->type = AUTH_LINK_TYPE_BLE;
684 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
685 SoftBusFree(connInfo);
686 }
687
688 /*
689 * @tc.name: AUTH_DEVICE_CHECK_CONN_INFO_TEST_001
690 * @tc.desc: fsm msg type to str test
691 * @tc.type: FUNC
692 * @tc.require:
693 */
694 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CHECK_CONN_INFO_TEST_001, TestSize.Level1)
695 {
696 const char *uuid = "test66";
697 AuthLinkType type = AUTH_LINK_TYPE_WIFI;
698 bool checkConnection = false;
699 bool ret = AuthDeviceCheckConnInfo(uuid, type, checkConnection);
700 EXPECT_TRUE(ret == false);
701 }
702
703 /*
704 * @tc.name: CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001
705 * @tc.desc: sync deviceInfo state process test
706 * @tc.type: FUNC
707 * @tc.require:
708 */
709 HWTEST_F(AuthOtherTest, CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001, TestSize.Level1)
710 {
711 AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
712 ASSERT_TRUE(authFsm != nullptr);
713 authFsm->info.connInfo.type = (AuthLinkType)(AUTH_LINK_TYPE_WIFI - 1);
714 ReportAuthResultEvt(authFsm, 0);
715
716 authFsm->info.connInfo.type = AUTH_LINK_TYPE_WIFI;
717 SoftBusLinkType ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_WIFI);
718 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_WLAN);
719
720 authFsm->info.connInfo.type = AUTH_LINK_TYPE_BR;
721 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BR);
722 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BR);
723
724 authFsm->info.connInfo.type = AUTH_LINK_TYPE_BLE;
725 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BLE);
726 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BLE);
727
728 authFsm->info.connInfo.type = AUTH_LINK_TYPE_P2P;
729 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_P2P);
730 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_P2P);
731
732 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_SEND_FAIL);
733 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_DEVICE_DISCONNECTED);
734 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_HICHAIN_PROCESS_FAIL);
735 ReportAuthResultEvt(authFsm, 11);
736 AuthCommonInterfaceMock connMock;
737 EXPECT_CALL(connMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
738 int32_t ret1 = RecoveryFastAuthKey(authFsm);
739 EXPECT_TRUE(ret1 != SOFTBUS_OK);
740 AuthSessionInfo authSessionInfo;
741 authSessionInfo.requestId = 11;
742 authSessionInfo.isServer = false;
743 authSessionInfo.connInfo.type = AUTH_LINK_TYPE_WIFI;
744 const char *udid = "1111";
745 (void)strcpy_s(authSessionInfo.udid, UDID_BUF_LEN, udid);
746 authFsm->info = authSessionInfo;
747 authFsm->authSeq = 512;
748 const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
749 if (data == nullptr) {
750 SoftBusFree(authFsm);
751 return;
752 }
753 MessagePara *para = NewMessagePara(data, MSG_LEN);
754 HandleMsgRecvDeviceInfo(authFsm, para);
755 authSessionInfo.isServer = true;
756 HandleMsgRecvDeviceInfo(authFsm, para);
757 SoftBusFree(authFsm);
758 }
759
760 /*
761 * @tc.name: POST_MESSAGE_TO_AUTH_FSM_TEST_001
762 * @tc.desc: post message to auth fsm test
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(AuthOtherTest, POST_MESSAGE_TO_AUTH_FSM_TEST_001, TestSize.Level1)
767 {
768 int32_t msgType = 1;
769 int64_t authSeq = 0;
770 const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
771 ASSERT_TRUE(data != nullptr);
772 uint32_t len = 0;
773 int32_t ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
774 EXPECT_TRUE(ret != SOFTBUS_OK);
775 len = MSG_LEN;
776 ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
777 EXPECT_TRUE(ret != SOFTBUS_OK);
778 }
779
780 /*
781 * @tc.name: AUTH_FSM_TEST_001
782 * @tc.desc: authSession handle device disconnected test
783 * @tc.type: FUNC
784 * @tc.require:
785 */
786 HWTEST_F(AuthOtherTest, AUTH_FSM_TEST_001, TestSize.Level1)
787 {
788 uint64_t connId = 111;
789 bool isServer = true;
790 AuthFsm *ret = GetAuthFsmByConnId(connId, isServer, false);
791 EXPECT_TRUE(ret == nullptr);
792 int32_t ret1 = AuthSessionHandleDeviceDisconnected(connId, true);
793 EXPECT_TRUE(ret1 == SOFTBUS_OK);
794 }
795
796 /*
797 * @tc.name: AUTH_RESTORE_MANAGER_TEST_001
798 * @tc.desc: authRestore authManager test
799 * @tc.type: FUNC
800 * @tc.require:
801 */
802 HWTEST_F(AuthOtherTest, AUTH_RESTORE_MANAGER_TEST_001, TestSize.Level1)
803 {
804 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
805 if (connInfo == nullptr) {
806 return;
807 }
808 connInfo->type = AUTH_LINK_TYPE_BLE;
809 uint32_t requestId = 1;
810 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
811 if (nodeInfo == nullptr) {
812 SoftBusFree(connInfo);
813 return;
814 }
815 int64_t *authId = reinterpret_cast<int64_t *>(malloc(sizeof(int64_t)));
816 int32_t ret = AuthRestoreAuthManager(nullptr, connInfo, requestId, nodeInfo, authId);
817 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
818 const char *udidHash = "1234uuid";
819 ret = AuthRestoreAuthManager(udidHash, nullptr, requestId, nodeInfo, authId);
820 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
821 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nullptr, authId);
822 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
823 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, nullptr);
824 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
825 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, authId);
826 EXPECT_EQ(ret, SOFTBUS_AUTH_MANAGER_RESTORE_FAIL);
827 const char *udidHash1 = "testudidhashpass";
828 ret = AuthRestoreAuthManager(udidHash1, connInfo, requestId, nodeInfo, authId);
829 EXPECT_EQ(ret, SOFTBUS_AUTH_MANAGER_RESTORE_FAIL);
830 SoftBusFree(connInfo);
831 SoftBusFree(nodeInfo);
832 }
833
834 /*
835 * @tc.name: GET_PEER_UDID_BY_NETWORK_ID_TEST_001
836 * @tc.desc: get peer udid by networkId test
837 * @tc.type: FUNC
838 * @tc.require:
839 */
840 HWTEST_F(AuthOtherTest, GET_PEER_UDID_BY_NETWORK_ID_TEST_001, TestSize.Level1)
841 {
842 const char *networkId = "testudid";
843 int32_t ret = GetPeerUdidByNetworkId(networkId, nullptr, UDID_BUF_LEN);
844 char udid[UDID_BUF_LEN] = { 0 };
845 ret = GetPeerUdidByNetworkId(nullptr, udid, UDID_BUF_LEN);
846 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
847 ret = GetPeerUdidByNetworkId(networkId, udid, UDID_BUF_LEN);
848 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
849 }
850
851 /*
852 * @tc.name: GET_LATEST_ID_BY_CONNINFO_TEST_001
853 * @tc.desc: get latest id by connInfo test
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(AuthOtherTest, GET_LATEST_ID_BY_CONNINFO_TEST_001, TestSize.Level1)
858 {
859 int64_t ret = GetLatestIdByConnInfo(nullptr);
860 EXPECT_TRUE(ret == AUTH_INVALID_ID);
861 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
862 ASSERT_TRUE(connInfo != nullptr);
863 connInfo->type = AUTH_LINK_TYPE_WIFI;
864 const char *ip = "192.168.12.1";
865 (void)strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, ip);
866 ret = GetLatestIdByConnInfo(connInfo);
867 EXPECT_TRUE(ret == AUTH_INVALID_ID);
868 connInfo->type = AUTH_LINK_TYPE_BLE;
869 ret = GetLatestIdByConnInfo(connInfo);
870 EXPECT_TRUE(ret == AUTH_INVALID_ID);
871 SoftBusFree(connInfo);
872 }
873
874 /*
875 * @tc.name: START_RECONNECT_DEVICE_TEST_001
876 * @tc.desc: start reconnection device test
877 * @tc.type: FUNC
878 * @tc.require:
879 */
880 HWTEST_F(AuthOtherTest, START_RECONNECT_DEVICE_TEST_001, TestSize.Level1)
881 {
882 AuthConnInfo connInfo;
883 AuthConnCallback connCb;
884 AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
885 int32_t ret = AuthStartReconnectDevice(authHandle, &connInfo, 1, &connCb);
886 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
887
888 NodeInfo nodeInfo;
889 ReportAuthRequestPassed(11, authHandle, &nodeInfo);
890 AuthRequest request;
891 uint64_t connId = 10;
892 int32_t result = 1;
893 HandleReconnectResult(&request, connId, result, 0);
894 request.authId = 10;
895 request.requestId = 11;
896 HandleReconnectResult(&request, connId, result, 0);
897 }
898
899 /*
900 * @tc.name: AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001
901 * @tc.desc: auth get latest authsed list test
902 * @tc.type: FUNC
903 * @tc.require:
904 */
905 HWTEST_F(AuthOtherTest, AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001, TestSize.Level1)
906 {
907 int64_t seqList = 1024;
908 uint32_t num = 1;
909 int32_t ret = AuthGetLatestAuthSeqList(nullptr, &seqList, num);
910 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
911 const char *udid = "";
912 ret = AuthGetLatestAuthSeqList(udid, &seqList, num);
913 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
914 const char *udid1 = "11";
915 ret = AuthGetLatestAuthSeqList(udid1, nullptr, num);
916 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
917 ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
918 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
919 num = DISCOVERY_TYPE_COUNT;
920 ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
921 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
922
923 AuthConnInfo connInfo;
924 AuthDataHead head;
925 uint8_t data = 1;
926 head.flag = 0;
927 connInfo.type = AUTH_LINK_TYPE_BLE;
928 uint64_t connId = 11;
929 HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
930 head.flag = 1;
931 HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
932 }
933
934 /*
935 * @tc.name: SYNC_DEVINFO_STATE_PROCESS_TEST_001
936 * @tc.desc: sync deviceInfo state process test
937 * @tc.type: FUNC
938 * @tc.require:
939 */
940 HWTEST_F(AuthOtherTest, SYNC_DEVINFO_STATE_PROCESS_TEST_001, TestSize.Level1)
941 {
942 FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
943 ASSERT_TRUE(fsm != nullptr);
944 int32_t msgType = 1;
945 bool ret = SyncDevInfoStateProcess(fsm, msgType, nullptr);
946 EXPECT_TRUE(ret == false);
947 SoftBusFree(fsm);
948 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
949 ASSERT_TRUE(testFsm != nullptr);
950 testFsm->flag = 1;
951
952 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
953 EXPECT_TRUE(ret == false);
954
955 msgType = FSM_MSG_AUTH_TIMEOUT;
956 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
957 msgType = FSM_MSG_RECV_DEVICE_INFO;
958 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
959 EXPECT_TRUE(ret == false);
960
961 msgType = FSM_MSG_RECV_CLOSE_ACK;
962 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
963 EXPECT_TRUE(ret == false);
964
965 msgType = FSM_MSG_RECV_AUTH_DATA;
966 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
967 EXPECT_TRUE(ret == false);
968
969 msgType = FSM_MSG_AUTH_FINISH;
970 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
971 EXPECT_TRUE(ret == false);
972 SoftBusFree(testFsm);
973 }
974
975 /*
976 * @tc.name: GET_AUTH_CONN_001
977 * @tc.desc: get auth conn test
978 * @tc.type: FUNC
979 * @tc.require:
980 */
981 HWTEST_F(AuthOtherTest, GET_AUTH_CONN_001, TestSize.Level1)
982 {
983 const char *uuid = "testuuid123";
984
985 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
986 ASSERT_TRUE(connInfo != nullptr);
987
988 int32_t ret = GetAuthConn(uuid, LANE_BR, nullptr);
989 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
990
991 ret = GetAuthConn(nullptr, LANE_BR, connInfo);
992 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
993
994 connInfo->type = AUTH_LINK_TYPE_BR;
995 ret = GetAuthConn(uuid, LANE_BR, connInfo);
996 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
997
998 connInfo->type = AUTH_LINK_TYPE_BLE;
999 ret = GetAuthConn(uuid, LANE_BLE, connInfo);
1000 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1001
1002 connInfo->type = AUTH_LINK_TYPE_P2P;
1003 ret = GetAuthConn(uuid, LANE_P2P, connInfo);
1004 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1005
1006 ret = GetAuthConn(uuid, LANE_HML, connInfo);
1007 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1008
1009 ret = GetAuthConn(uuid, LANE_WLAN_2P4G, connInfo);
1010 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1011
1012 SoftBusFree(connInfo);
1013 }
1014
1015 /*
1016 * @tc.name: AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001
1017 * @tc.desc: AuthGetAuthHandleByIndex test
1018 * @tc.type: FUNC
1019 * @tc.require:
1020 */
1021 HWTEST_F(AuthOtherTest, AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001, TestSize.Level1)
1022 {
1023 AuthConnInfo connInfo = {
1024 .info.ipInfo.ip = "192.168.12.1",
1025 .type = AUTH_LINK_TYPE_WIFI,
1026 };
1027 AuthHandle authHandle;
1028 (void)memset_s(&authHandle, sizeof(AuthHandle), 0, sizeof(AuthHandle));
1029 EXPECT_TRUE(AuthGetAuthHandleByIndex(nullptr, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1030 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1031 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1032 char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
1033 connInfo.type = AUTH_LINK_TYPE_BLE;
1034 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
1035 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_NOT_FIND);
1036 char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
1037 connInfo.type = AUTH_LINK_TYPE_BR;
1038 ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
1039 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1040 connInfo.type = AUTH_LINK_TYPE_MAX;
1041 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1042 }
1043
1044 /*
1045 * @tc.name: AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001
1046 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(AuthOtherTest, AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001, TestSize.Level1)
1051 {
1052 const char *networkId = "123456456";
1053 AuthConnInfo connInfo;
1054 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo) == SOFTBUS_INVALID_PARAM);
1055 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, nullptr) == SOFTBUS_INVALID_PARAM);
1056 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo) == SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1057 EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(nullptr) == SOFTBUS_INVALID_PARAM);
1058 AuthHandle authHandle = {
1059 .type = AUTH_LINK_TYPE_WIFI,
1060 .authId = 0,
1061 };
1062 EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(&authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID);
1063 authHandle.type = -1;
1064 AuthTransData dataInfo;
1065 AuthCloseConn(authHandle);
1066 EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1067 EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1068 authHandle.type = AUTH_LINK_TYPE_MAX;
1069 AuthCloseConn(authHandle);
1070 EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1071 EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1072 AuthFreeLane(nullptr);
1073 DelAuthReqInfoByAuthHandle(nullptr);
1074 AuthFreeLane(&authHandle);
1075 DelAuthReqInfoByAuthHandle(&authHandle);
1076 AuthConnCallback callback;
1077 EXPECT_TRUE(AuthAllocLane(nullptr, 1, &callback) == SOFTBUS_INVALID_PARAM);
1078 EXPECT_TRUE(AuthAllocLane(networkId, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1079 EXPECT_TRUE(AuthAllocLane(nullptr, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1080 EXPECT_TRUE(AuthGetP2pConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1081 EXPECT_TRUE(AuthGetHmlConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1082 AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, nullptr);
1083 AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, &authHandle);
1084 }
1085
1086 /*
1087 * @tc.name: AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001
1088 * @tc.desc: AuthDirectOnlineProcessSessionKey test
1089 * @tc.type: FUNC
1090 * @tc.require:
1091 */
1092 HWTEST_F(AuthOtherTest, AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001, TestSize.Level1)
1093 {
1094 AuthDeviceKeyInfo keyInfo = {
1095 .keyLen = strlen("testKey"),
1096 .isOldKey = true,
1097 };
1098 ASSERT_TRUE(memcpy_s(keyInfo.deviceKey, SESSION_KEY_LENGTH, "testKey", strlen("testKey")) == EOK);
1099 AuthSessionInfo info = {
1100 .connInfo.type = AUTH_LINK_TYPE_BR,
1101 };
1102 int64_t authId;
1103 EXPECT_EQ(AuthDirectOnlineProcessSessionKey(&info, &keyInfo, &authId), SOFTBUS_AUTH_NOT_FOUND);
1104 EXPECT_EQ(AuthDirectOnlineWithoutSessionKey(&info, &keyInfo, &authId), SOFTBUS_AUTH_UNEXPECTED_CONN_TYPE);
1105 EXPECT_TRUE(AuthEncrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1106 EXPECT_TRUE(AuthDecrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1107 }
1108
1109 /*
1110 * @tc.name: IS_SAME_ACCOUNT_DEVICE_TEST_001
1111 * @tc.desc: IsSameAccountDevice test
1112 * @tc.type: FUNC
1113 * @tc.require:
1114 */
1115 HWTEST_F(AuthOtherTest, IS_SAME_ACCOUNT_DEVICE_TEST_001, TestSize.Level1)
1116 {
1117 AuthCommonInterfaceMock connMock;
1118 EXPECT_CALL(connMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1119 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
1120 uint8_t accountHash[SHA_256_HASH_LEN] = "accounthashtest";
1121 EXPECT_TRUE(LnnSetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) == SOFTBUS_OK);
1122 EXPECT_TRUE(AuthIsPotentialTrusted(nullptr, true) == false);
1123 DeviceInfo device = {
1124 .devId = "testId",
1125 .accountHash = "accounthashtest",
1126 };
1127 EXPECT_TRUE(AuthIsPotentialTrusted(&device, true) == true);
1128 EXPECT_TRUE(IsSameAccountDevice(nullptr) == false);
1129 EXPECT_TRUE(IsSameAccountDevice(&device) == true);
1130 EXPECT_TRUE(AuthHasSameAccountGroup() == false);
1131 }
1132
1133 /*
1134 * @tc.name: FILL_AUTH_SESSION_INFO_TEST_001
1135 * @tc.desc: FillAuthSessionInfo test
1136 * @tc.type: FUNC
1137 * @tc.require:
1138 */
1139 HWTEST_F(AuthOtherTest, FILL_AUTH_SESSION_INFO_TEST_001, TestSize.Level1)
1140 {
1141 AuthCommonInterfaceMock connMock;
1142 EXPECT_CALL(connMock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1143 AuthSessionInfo info = {
1144 .connInfo.info.bleInfo.deviceIdHash = "123456789udidhashtest",
1145 };
1146 NodeInfo nodeInfo = {
1147 .authCapacity = 127,
1148 .uuid = "123456789uuidhashtest",
1149 .deviceInfo.deviceUdid = "123456789udidtest",
1150 };
1151 AuthDeviceKeyInfo keyInfo;
1152 EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, true) == SOFTBUS_OK);
1153 EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, false) == SOFTBUS_OK);
1154 }
1155
1156 /*
1157 * @tc.name: DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001
1158 * @tc.desc: DelAuthReqInfoByAuthHandle test
1159 * @tc.type: FUNC
1160 * @tc.require:
1161 */
1162 HWTEST_F(AuthOtherTest, DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001, TestSize.Level1)
1163 {
1164 InitAuthReqInfo();
1165 AuthConnCallback authConnCb = {
1166 .onConnOpened = OnConnOpenedTest,
1167 .onConnOpenFailed = OnConnOpenFailedTest,
1168 };
1169 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 1, 1, &authConnCb), SOFTBUS_OK);
1170 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 2, 2, &authConnCb), SOFTBUS_OK);
1171 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 3, 3, &authConnCb), SOFTBUS_OK);
1172 OnAuthConnOpenedFail(1, -1);
1173 OnAuthConnOpenedFail(4, -1);
1174 AuthHandle authHandle = {
1175 .authId = 2,
1176 .type = 1,
1177 };
1178 AuthFreeLane(&authHandle);
1179 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1180 authHandle.type = 0;
1181 AuthFreeLane(&authHandle);
1182 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1183 authHandle.authId = 1;
1184 AuthFreeLane(&authHandle);
1185 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1186 authHandle.authId = 2;
1187 AuthFreeLane(&authHandle);
1188 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1189 DeInitAuthReqInfo();
1190 }
1191
1192 /*
1193 * @tc.name: IS_ENHANCE_P2P_MODULE_ID_TEST_001
1194 * @tc.desc: IsEnhanceP2pModuleId test
1195 * @tc.type: FUNC
1196 * @tc.require:
1197 */
1198 HWTEST_F(AuthOtherTest, IS_ENHANCE_P2P_MODULE_ID_TEST_001, TestSize.Level1)
1199 {
1200 EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_ENHANCED_P2P_START), true);
1201 EXPECT_EQ(IsEnhanceP2pModuleId(DIRECT_CHANNEL_SERVER_P2P), false);
1202 EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_P2P), false);
1203 }
1204
1205 /*
1206 * @tc.name: AUTH_START_LISTENING_FOR_WIFI_DIRECT_TEST_001
1207 * @tc.desc: AuthStartListeningForWifiDirect test
1208 * @tc.type: FUNC
1209 * @tc.require:
1210 */
1211 HWTEST_F(AuthOtherTest, AUTH_START_LISTENING_FOR_WIFI_DIRECT_TEST_001, TestSize.Level1)
1212 {
1213 AsyncCallDeviceIdReceived(nullptr);
1214 AuthCommonInterfaceMock connMock;
1215 EXPECT_CALL(connMock, ConnStopLocalListening).WillRepeatedly(Return(SOFTBUS_OK));
1216 EXPECT_CALL(connMock, ConnStartLocalListening).WillRepeatedly(Return(0));
1217 AuthStopListeningForWifiDirect(AUTH_LINK_TYPE_P2P, AUTH_ENHANCED_P2P_START);
1218 AuthDataHead head;
1219 const uint8_t data[TEST_DATA_LEN] = { 0 };
1220 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
1221 OnWiFiDataReceived(PROXY, 0, &head, data);
1222 OnWiFiDataReceived(AUTH, 0, &head, data);
1223 OnWiFiDataReceived(AUTH_P2P, 0, &head, data);
1224 OnWiFiDataReceived(AUTH_RAW_P2P_SERVER, 0, &head, data);
1225 OnWiFiDataReceived(AUTH_ENHANCED_P2P_START, 0, &head, data);
1226 const char *ip = "192.138.33.33";
1227 ListenerModule moduleId;
1228 (void)memset_s(&moduleId, sizeof(ListenerModule), 0, sizeof(ListenerModule));
1229 EXPECT_NE(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_P2P, ip, 37025, &moduleId), SOFTBUS_INVALID_PORT);
1230 EXPECT_NE(
1231 AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_ENHANCED_P2P, ip, 37025, &moduleId), SOFTBUS_INVALID_PORT);
1232 EXPECT_EQ(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_WIFI, ip, 37025, &moduleId), SOFTBUS_INVALID_PARAM);
1233 }
1234
1235 /*
1236 * @tc.name: IS_AUTH_SESSION_KEY_MODULE_TEST_001
1237 * @tc.desc: IsAuthSessionKeyModule test
1238 * @tc.type: FUNC
1239 * @tc.require:
1240 */
1241 HWTEST_F(AuthOtherTest, IS_AUTH_SESSION_KEY_MODULE_TEST_001, TestSize.Level1)
1242 {
1243 AuthDataHead head;
1244
1245 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
1246 head.dataType = DATA_TYPE_AUTH;
1247 bool ret = IsAuthSessionKeyModule(&head);
1248 EXPECT_TRUE(ret);
1249 head.dataType = DATA_TYPE_DEVICE_INFO;
1250 ret = IsAuthSessionKeyModule(&head);
1251 EXPECT_TRUE(ret);
1252 head.dataType = DATA_TYPE_DEVICE_ID;
1253 ret = IsAuthSessionKeyModule(&head);
1254 EXPECT_TRUE(ret);
1255 head.dataType = DATA_TYPE_CLOSE_ACK;
1256 ret = IsAuthSessionKeyModule(&head);
1257 EXPECT_TRUE(ret);
1258 head.dataType = DATA_TYPE_CONNECTION;
1259 ret = IsAuthSessionKeyModule(&head);
1260 EXPECT_FALSE(ret);
1261 }
1262
1263 /*
1264 * @tc.name: ON_WIFI_CONNECTED_TEST_001
1265 * @tc.desc: OnWiFiConnected test
1266 * @tc.type: FUNC
1267 * @tc.require:
1268 */
1269 HWTEST_F(AuthOtherTest, ON_WIFI_CONNECTED_TEST_001, TestSize.Level1)
1270 {
1271 ListenerModule module = AUTH;
1272 int32_t fd = 1;
1273 bool isClient = false;
1274
1275 OnWiFiConnected(module, fd, isClient);
1276 isClient = true;
1277 OnWiFiConnected(module, fd, isClient);
1278
1279 bool ret = IsSessionAuth(module);
1280 EXPECT_FALSE(ret);
1281 }
1282
1283 /*
1284 * @tc.name: ON_TCP_SESSION_CONNECTED_TEST_001
1285 * @tc.desc: OnTcpSessionConnected test
1286 * @tc.type: FUNC
1287 * @tc.require:
1288 */
1289 HWTEST_F(AuthOtherTest, ON_TCP_SESSION_CONNECTED_TEST_001, TestSize.Level1)
1290 {
1291 ListenerModule module = AUTH;
1292 int32_t fd = 1;
1293 bool isClient = false;
1294
1295 OnTcpSessionConnected(module, fd, isClient);
1296 isClient = true;
1297 OnTcpSessionConnected(module, fd, isClient);
1298
1299 bool ret = IsSessionAuth(module);
1300 EXPECT_FALSE(ret);
1301 }
1302
1303 /*
1304 * @tc.name: ON_WIFI_DISCONNECTED_TEST_001
1305 * @tc.desc: OnWiFiDisconnected test
1306 * @tc.type: FUNC
1307 * @tc.require:
1308 */
1309 HWTEST_F(AuthOtherTest, ON_WIFI_DISCONNECTED_TEST_001, TestSize.Level1)
1310 {
1311 ListenerModule module = AUTH;
1312 int32_t fd = 1;
1313
1314 OnWiFiDisconnected(module, fd);
1315 module = AUTH_USB;
1316 OnWiFiDisconnected(module, fd);
1317 module = AUTH_SESSION_KEY;
1318 OnWiFiDisconnected(module, fd);
1319
1320 bool ret = IsSessionAuth(module);
1321 EXPECT_FALSE(ret);
1322 }
1323 } // namespace OHOS
1324