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 <securec.h>
19 #include <sys/time.h>
20
21 #include "auth_request.h"
22 #include "auth_session_fsm.c"
23 #include "auth_session_fsm.h"
24 #include "auth_session_fsm_mock.h"
25 #include "softbus_adapter_mem.h"
26
27 namespace OHOS {
28 using namespace testing;
29 using namespace testing::ext;
30 constexpr int64_t AUTH_SEQ = 1;
31 constexpr int64_t AUTH_SEQ_1 = 2;
32 constexpr uint64_t CONN_ID = 10;
33 constexpr uint64_t CONN_ID_1 = 11;
34 constexpr int32_t DEVICE_ID_HASH_LEN = 9;
35 constexpr uint32_t REQUEST_ID = 1000;
36 constexpr uint32_t REQUEST_ID_1 = 1001;
37 constexpr int32_t TMP_DATA_LEN = 10;
38 constexpr int32_t TEST_REQUEST_ID = 123;
39 constexpr char UDID_HASH[UDID_HASH_LEN] = "9ada389cd0898797";
40 constexpr char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
41 constexpr char INVALID_UDID_TEST[UDID_BUF_LEN] = "nullptr";
42 constexpr char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
43 constexpr char BLE_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
44 constexpr char SLE_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
45 constexpr uint8_t DEVICE_ID_HASH[UDID_HASH_LEN] = "123456789";
46 constexpr uint8_t TMP_IN_DATA[TMP_DATA_LEN] = "tmpInData";
47
48 class AuthSessionFsmTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54 };
55
SetUpTestCase()56 void AuthSessionFsmTest::SetUpTestCase()
57 {
58 GTEST_LOG_(INFO) << "AuthSessionFsmTest start";
59 AuthCommonInit();
60 }
61
TearDownTestCase()62 void AuthSessionFsmTest::TearDownTestCase()
63 {
64 AuthCommonDeinit();
65 GTEST_LOG_(INFO) << "AuthSessionFsmTest end";
66 }
67
SetUp()68 void AuthSessionFsmTest::SetUp() { }
69
TearDown()70 void AuthSessionFsmTest::TearDown() { }
71
72 /*
73 * @tc.name: TRANSLATE_TO_AUTH_FSM_TEST_001
74 * @tc.desc: TranslateToAuthFsm test
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(AuthSessionFsmTest, TRANSLATE_TO_AUTH_FSM_TEST_001, TestSize.Level1)
79 {
80 EXPECT_TRUE(strcmp(FsmMsgTypeToStr(-1), "UNKNOWN MSG!!") == EOK);
81 EXPECT_TRUE(strcmp(FsmMsgTypeToStr(FSM_MSG_UNKNOWN), "UNKNOWN MSG!!") == EOK);
82 EXPECT_TRUE(strcmp(FsmMsgTypeToStr(FSM_MSG_AUTH_FINISH), "AUTH_FINISH") == EOK);
83 AuthConnInfo connInfo;
84 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
85 connInfo.type = AUTH_LINK_TYPE_BR;
86 ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
87 AuthFsmParam authFsmParam;
88 (void)memset_s(&authFsmParam, sizeof(authFsmParam), 0, sizeof(authFsmParam));
89 authFsmParam.authSeq = AUTH_SEQ;
90 authFsmParam.requestId = REQUEST_ID;
91 authFsmParam.connId = CONN_ID;
92 authFsmParam.isServer = true;
93 authFsmParam.deviceKeyId.hasDeviceKeyId = false;
94 authFsmParam.deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
95 authFsmParam.deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
96 AuthFsm *authFsm = CreateAuthFsm(&authFsmParam, &connInfo);
97 EXPECT_TRUE(authFsm == nullptr);
98 authFsm = TranslateToAuthFsm(nullptr, FSM_MSG_AUTH_TIMEOUT, nullptr);
99 EXPECT_TRUE(authFsm == nullptr);
100 authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_AUTH_TIMEOUT, nullptr);
101 EXPECT_TRUE(authFsm == nullptr);
102 authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_RECV_DEVICE_ID, nullptr);
103 EXPECT_TRUE(authFsm == nullptr);
104 authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_UNKNOWN, nullptr);
105 EXPECT_TRUE(authFsm == nullptr);
106 AuthFsmDeinitCallback(nullptr);
107 }
108
109 /*
110 * @tc.name: PROC_AUTH_FSM_TEST_001
111 * @tc.desc: ProcAuthFsm test
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(AuthSessionFsmTest, PROC_AUTH_FSM_TEST_001, TestSize.Level1)
116 {
117 ClearAuthRequest();
118 AuthRequest request;
119 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
120 request.authId = REQUEST_ID;
121 request.type = REQUEST_TYPE_RECONNECT;
122 EXPECT_TRUE(SoftBusGenerateStrHash(
123 DEVICE_ID_HASH, DEVICE_ID_HASH_LEN, request.connInfo.info.bleInfo.deviceIdHash) == SOFTBUS_OK);
124 EXPECT_TRUE(AddAuthRequest(&request) == 0);
125 AuthConnInfo connInfo;
126 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
127 connInfo.type = AUTH_LINK_TYPE_BR;
128 AddUdidInfo(REQUEST_ID, true, &connInfo);
129 AddUdidInfo(REQUEST_ID, false, &connInfo);
130 connInfo.type = AUTH_LINK_TYPE_WIFI;
131 AddUdidInfo(REQUEST_ID, false, &connInfo);
132 connInfo.type = AUTH_LINK_TYPE_BLE;
133 AddUdidInfo(REQUEST_ID, false, &connInfo);
134 connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
135 AddUdidInfo(REQUEST_ID, false, &connInfo);
136 connInfo.type = AUTH_LINK_TYPE_USB;
137 AddUdidInfo(REQUEST_ID, false, &connInfo);
138 connInfo.type = AUTH_LINK_TYPE_MAX;
139 AddUdidInfo(REQUEST_ID, false, &connInfo);
140 AuthFsm authFsm;
141 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
142 authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
143 EXPECT_NE(ProcAuthFsm(REQUEST_ID_1, true, &authFsm), SOFTBUS_OK);
144 EXPECT_NE(ProcAuthFsm(REQUEST_ID, true, &authFsm), SOFTBUS_OK);
145 authFsm.info.connInfo.type = AUTH_LINK_TYPE_WIFI;
146 EXPECT_TRUE(ProcAuthFsm(REQUEST_ID, true, &authFsm) == SOFTBUS_OK);
147 authFsm.authSeq = AUTH_SEQ_1;
148 authFsm.info.isServer = false;
149 authFsm.info.isSupportFastAuth = false;
150 authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
151 CompleteAuthSession(&authFsm, SOFTBUS_OK);
152 authFsm.info.isSupportFastAuth = true;
153 CompleteAuthSession(&authFsm, SOFTBUS_OK);
154 authFsm.info.normalizedType = NORMALIZED_KEY_ERROR;
155 authFsm.info.isConnectServer = true;
156 authFsm.info.peerState = AUTH_STATE_ACK;
157 CompleteAuthSession(&authFsm, SOFTBUS_OK);
158 }
159
160 /*
161 * @tc.name: RECOVERY_DEVICE_KEY_TEST_001
162 * @tc.desc: RecoveryFastAuthKey test
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(AuthSessionFsmTest, RECOVERY_DEVICE_KEY_TEST_001, TestSize.Level1)
167 {
168 AuthFsm authFsm;
169 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
170 authFsm.info.isNodeInfoReceived = true;
171 authFsm.info.isCloseAckReceived = true;
172 HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_NOT_TRUSTED, nullptr);
173 HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
174 authFsm.info.isCloseAckReceived = false;
175 HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
176 authFsm.info.isNodeInfoReceived = false;
177 HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
178 HandleCommonMsg(&authFsm, SOFTBUS_AUTH_INNER_ERR, nullptr);
179 ASSERT_TRUE(memcpy_s(authFsm.info.udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
180 authFsm.info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
181 EXPECT_NE(RecoveryFastAuthKey(&authFsm), SOFTBUS_OK);
182 authFsm.info.connInfo.type = AUTH_LINK_TYPE_WIFI;
183 EXPECT_NE(RecoveryFastAuthKey(&authFsm), SOFTBUS_OK);
184 SyncDevIdStateEnter(nullptr);
185 }
186
187 /*
188 * @tc.name: CLIENT_SET_EXCHANGE_ID_TYPE_TEST_001
189 * @tc.desc: ClientSetExchangeIdType test
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(AuthSessionFsmTest, CLIENT_SET_EXCHANGE_ID_TYPE_TEST_001, TestSize.Level1)
194 {
195 NiceMock<AuthSessionFsmInterfaceMock> mock;
196 LnnAuditExtra *auditData = reinterpret_cast<LnnAuditExtra *>(SoftBusMalloc(sizeof(LnnAuditExtra)));
197 EXPECT_TRUE(auditData != nullptr);
198 AuthSessionInfo info;
199 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
200 (void)memset_s(auditData, sizeof(LnnAuditExtra), 0, sizeof(LnnAuditExtra));
201 AuditReportSetPeerDevInfo(nullptr, &info);
202 AuditReportSetPeerDevInfo(auditData, nullptr);
203 info.connInfo.type = AUTH_LINK_TYPE_BR;
204 EXPECT_TRUE(memcpy_s(info.connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
205 AuditReportSetPeerDevInfo(auditData, &info);
206 info.connInfo.type = AUTH_LINK_TYPE_BLE;
207 EXPECT_TRUE(memcpy_s(info.connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
208 AuditReportSetPeerDevInfo(auditData, &info);
209 info.connInfo.type = AUTH_LINK_TYPE_SLE;
210 EXPECT_TRUE(memcpy_s(info.connInfo.info.sleInfo.sleMac, BT_MAC_LEN, SLE_MAC, strlen(SLE_MAC)) == EOK);
211 AuditReportSetPeerDevInfo(auditData, &info);
212 info.connInfo.type = AUTH_LINK_TYPE_MAX;
213 AuditReportSetPeerDevInfo(auditData, &info);
214 AuditReportSetLocalDevInfo(nullptr);
215 BuildLnnAuditEvent(nullptr, &info, SOFTBUS_OK, SOFTBUS_OK, AUDIT_EVENT_PACKETS_ERROR);
216 BuildLnnAuditEvent(auditData, nullptr, SOFTBUS_OK, SOFTBUS_OK, AUDIT_EVENT_PACKETS_ERROR);
217 SoftBusFree(auditData);
218 AuthFsm authFsm;
219 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
220 authFsm.info.idType = EXCHANGE_FAIL;
221 EXPECT_NE(ClientSetExchangeIdType(&authFsm), SOFTBUS_OK);
222 EXPECT_CALL(mock, PostDeviceInfoMessage).WillOnce(Return(SOFTBUS_ENCRYPT_ERR));
223 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
224 info.isServer = true;
225 EXPECT_TRUE(TrySyncDeviceInfo(AUTH_SEQ_1, &info) == SOFTBUS_OK);
226 info.isServer = false;
227 EXPECT_TRUE(TrySyncDeviceInfo(AUTH_SEQ_1, &info) == SOFTBUS_ENCRYPT_ERR);
228 info.connInfo.type = AUTH_LINK_TYPE_MAX;
229 EXPECT_NE(TrySyncDeviceInfo(AUTH_SEQ_1, &info), SOFTBUS_OK);
230 }
231
232 /*
233 * @tc.name: GET_AUTH_FSM_TEST_001
234 * @tc.desc: GetAuthFsmByConnId test
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(AuthSessionFsmTest, GET_AUTH_FSM_TEST_001, TestSize.Level1)
239 {
240 AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
241 ASSERT_TRUE(authFsm != nullptr);
242 (void)memset_s(authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
243 ASSERT_TRUE(memcpy_s(authFsm->info.udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
244 authFsm->authSeq = AUTH_SEQ;
245 authFsm->info.connId = CONN_ID;
246 authFsm->info.isServer = true;
247 authFsm->isDead = true;
248 ListNodeInsert(&g_authFsmList, &authFsm->node);
249 EXPECT_TRUE(GetAuthFsmByAuthSeq(AUTH_SEQ) == nullptr);
250 EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID_1, false, false) == nullptr);
251 EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID, false, false) == nullptr);
252 EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID, true, false) == nullptr);
253 }
254
255 /*
256 * @tc.name: AUTH_SESSION_HANDLE_TEST_001
257 * @tc.desc: AuthSessionHandle test
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_HANDLE_TEST_001, TestSize.Level1)
262 {
263 AuthFsm authFsm;
264 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
265 authFsm.info.deviceInfoData = nullptr;
266 MessagePara para;
267 (void)memset_s(¶, sizeof(MessagePara), 0, sizeof(MessagePara));
268 ASSERT_TRUE(memcpy_s(para.data, TMP_DATA_LEN, TMP_IN_DATA, TMP_DATA_LEN) == EOK);
269 para.len = TMP_DATA_LEN;
270 HandleMsgRecvDevInfoEarly(&authFsm, ¶);
271 authFsm.info.deviceInfoData = reinterpret_cast<uint8_t *>(SoftBusMalloc(TMP_DATA_LEN));
272 EXPECT_TRUE(authFsm.info.deviceInfoData != nullptr);
273 para.len = 0;
274 HandleMsgRecvDevInfoEarly(&authFsm, ¶);
275 TryFinishAuthSession(&authFsm);
276 authFsm.info.isNodeInfoReceived = true;
277 TryFinishAuthSession(&authFsm);
278 authFsm.info.isCloseAckReceived = true;
279 TryFinishAuthSession(&authFsm);
280 authFsm.info.isAuthFinished = true;
281 TryFinishAuthSession(&authFsm);
282 EXPECT_TRUE(AuthSessionHandleDeviceNotTrusted(INVALID_UDID_TEST) == SOFTBUS_OK);
283 EXPECT_TRUE(AuthSessionHandleDeviceNotTrusted(UDID_TEST) == SOFTBUS_OK);
284 EXPECT_TRUE(AuthSessionHandleDeviceDisconnected(CONN_ID_1, true) == SOFTBUS_OK);
285 EXPECT_TRUE(AuthSessionHandleDeviceDisconnected(CONN_ID, true) == SOFTBUS_OK);
286 AuthSessionFsmExit();
287 }
288
289 /*
290 * @tc.name: HANDLE_CLOSE_ACK_TEST_001
291 * @tc.desc: handle close ack base remote info
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(AuthSessionFsmTest, HANDLE_CLOSE_ACK_TEST_001, TestSize.Level1)
296 {
297 AuthSessionInfo info = { 0 };
298 info.nodeInfo.feature = 0xF7CA;
299 AuthSessionFsmInterfaceMock mock;
300 AuthFsm authFsm;
301 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
302
303 EXPECT_CALL(mock, SoftBusGetBrState()).WillRepeatedly(Return(BR_ENABLE));
304 int32_t ret = HandleCloseAckMessage(&authFsm, &info);
305 EXPECT_NE(ret, SOFTBUS_OK);
306
307 EXPECT_CALL(mock, SoftBusGetBrState()).WillRepeatedly(Return(BR_DISABLE));
308 ret = HandleCloseAckMessage(&authFsm, &info);
309 EXPECT_NE(ret, SOFTBUS_OK);
310 UpdateUdidHashIfEmpty(&authFsm, &info);
311 info.connInfo.type = AUTH_LINK_TYPE_BLE;
312 info.nodeInfo.feature = 0;
313 ret = HandleCloseAckMessage(&authFsm, &info);
314 EXPECT_NE(ret, SOFTBUS_OK);
315 EXPECT_EQ(memcpy_s(info.udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)), 0);
316 UpdateUdidHashIfEmpty(&authFsm, &info);
317 info.nodeInfo.feature = 0x1F7CA;
318 ret = HandleCloseAckMessage(&authFsm, &info);
319 EXPECT_NE(ret, SOFTBUS_OK);
320 }
321
322 /*
323 * @tc.name: IS_NEED_EXCHANGE_NETWORKID_TEST_001
324 * @tc.desc:
325 * @tc.type: FUNC
326 * @tc.require:
327 */
328 HWTEST_F(AuthSessionFsmTest, IS_NEED_EXCHANGE_NETWORKID_TEST_001, TestSize.Level1)
329 {
330 NiceMock<AuthSessionFsmInterfaceMock> mock;
331 uint32_t feature = 0;
332 AuthFsm authFsm;
333 AuthSessionInfo info;
334 MessagePara para;
335 int32_t result = 0;
336 (void)memset_s(&authFsm, sizeof(authFsm), 0, sizeof(authFsm));
337 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
338 (void)memset_s(¶, sizeof(para), 0, sizeof(para));
339 info.localState = AUTH_STATE_START;
340 LocalAuthStateProc(&authFsm, &info, &result);
341 info.localState = AUTH_STATE_ACK;
342 LocalAuthStateProc(&authFsm, &info, &result);
343 info.localState = AUTH_STATE_WAIT;
344 LocalAuthStateProc(&authFsm, &info, &result);
345 info.localState = AUTH_STATE_COMPATIBLE;
346 LocalAuthStateProc(&authFsm, &info, &result);
347 info.localState = AUTH_STATE_UNKNOW;
348 LocalAuthStateProc(&authFsm, &info, &result);
349 HandleMsgRecvDeviceIdNego(&authFsm, ¶);
350 bool ret = IsNeedExchangeNetworkId(feature, BIT_SUPPORT_EXCHANGE_NETWORKID);
351 EXPECT_TRUE(ret == false);
352 }
353
354 /*
355 * @tc.name: ADD_CONCURRENT_AUTH_REQUEST_TEST_001
356 * @tc.desc:
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(AuthSessionFsmTest, ADD_CONCURRENT_AUTH_REQUEST_TEST_001, TestSize.Level1)
361 {
362 AuthFsm authFsm;
363 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
364 uint32_t ret = AddConcurrentAuthRequest(&authFsm);
365 EXPECT_TRUE(ret == 0);
366
367 EXPECT_TRUE(strcpy_s(authFsm.info.udidHash, SHA_256_HEX_HASH_LEN, UDID_HASH) == EOK);
368 ret = AddConcurrentAuthRequest(&authFsm);
369 EXPECT_TRUE(ret != 0);
370 StopAuthFsm(&authFsm);
371 SyncNegotiationEnter(nullptr);
372 }
373
374 /*
375 * @tc.name: RECOVERY_NORMALIZED_DEVICE_KEY_TEST_001
376 * @tc.desc:
377 * @tc.type: FUNC
378 * @tc.require:
379 */
380 HWTEST_F(AuthSessionFsmTest, RECOVERY_NORMALIZED_DEVICE_KEY_TEST_001, TestSize.Level1)
381 {
382 AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
383 ASSERT_TRUE(authFsm != nullptr);
384 (void)memset_s(authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
385 authFsm->info.normalizedKey = nullptr;
386 int32_t ret = RecoveryNormalizedDeviceKey(authFsm);
387 EXPECT_NE(ret, SOFTBUS_OK);
388
389 authFsm->info.normalizedKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
390 if (authFsm->info.normalizedKey == nullptr) {
391 SoftBusFree(authFsm);
392 return;
393 }
394 ret = RecoveryNormalizedDeviceKey(authFsm);
395 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
396
397 EXPECT_TRUE(strcpy_s(authFsm->info.udidHash, SHA_256_HEX_HASH_LEN, UDID_HASH) == EOK);
398 ret = RecoveryNormalizedDeviceKey(authFsm);
399 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
400 SoftBusFree(authFsm->info.normalizedKey);
401 SoftBusFree(authFsm);
402 }
403
404 /*
405 * @tc.name: TRY_RECOVERY_KEY_TEST_001
406 * @tc.desc:
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(AuthSessionFsmTest, TRY_RECOVERY_KEY_TEST_001, TestSize.Level1)
411 {
412 AuthFsm authFsm;
413 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
414 authFsm.info.normalizedType = NORMALIZED_SUPPORT;
415 int32_t ret = TryRecoveryKey(&authFsm);
416 EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
417
418 authFsm.info.normalizedType = NORMALIZED_NOT_SUPPORT;
419 authFsm.info.isSupportFastAuth = true;
420 ret = TryRecoveryKey(&authFsm);
421 EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
422
423 authFsm.info.isSupportFastAuth = false;
424 ret = TryRecoveryKey(&authFsm);
425 EXPECT_TRUE(ret == SOFTBUS_OK);
426 }
427
428 /*
429 * @tc.name: PROCESS_CLIENT_AUTH_STATE_TEST_001
430 * @tc.desc:
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(AuthSessionFsmTest, PROCESS_CLIENT_AUTH_STATE_TEST_001, TestSize.Level1)
435 {
436 NiceMock<AuthSessionFsmInterfaceMock> mock;
437 AuthFsm authFsm;
438 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
439 authFsm.info.idType = EXCHANGE_FAIL;
440 int32_t ret = ProcessClientAuthState(&authFsm);
441 EXPECT_TRUE(ret == SOFTBUS_OK);
442
443 authFsm.info.idType = EXCHANGE_TYPE_MAX;
444 ret = ProcessClientAuthState(&authFsm);
445 EXPECT_TRUE(ret != SOFTBUS_OK);
446
447 DeviceAuthStateEnter(nullptr);
448 FsmStateMachine fsm;
449 (void)memset_s(&fsm, sizeof(FsmStateMachine), 0, sizeof(FsmStateMachine));
450 DeviceAuthStateEnter(&fsm);
451 }
452
453 /*
454 * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_001
455 * @tc.desc:
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_001, TestSize.Level1)
460 {
461 NiceMock<AuthSessionFsmInterfaceMock> mock;
462 AuthFsm authFsm;
463 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
464 authFsm.isDead = false;
465 int32_t msgType = FSM_MSG_RECV_DEVICE_ID;
466 MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
467 ASSERT_TRUE(para1 != nullptr);
468 bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
469 EXPECT_TRUE(ret == true);
470
471 MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
472 ASSERT_TRUE(para2 != nullptr);
473 msgType = FSM_MSG_RECV_AUTH_DATA;
474 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
475 EXPECT_TRUE(ret == true);
476
477 MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
478 ASSERT_TRUE(para3 != nullptr);
479 msgType = FSM_MSG_SAVE_SESSION_KEY;
480 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
481 EXPECT_TRUE(ret == false);
482
483 MessagePara *para4 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
484 ASSERT_TRUE(para4 != nullptr);
485 msgType = FSM_MSG_AUTH_ERROR;
486 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para4);
487 EXPECT_TRUE(ret == false);
488 }
489
490 /*
491 * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_002
492 * @tc.desc:
493 * @tc.type: FUNC
494 * @tc.require:
495 */
496 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_002, TestSize.Level1)
497 {
498 NiceMock<AuthSessionFsmInterfaceMock> mock;
499 AuthFsm authFsm;
500 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
501 authFsm.isDead = false;
502 int32_t msgType = FSM_MSG_AUTH_FINISH;
503 MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
504 ASSERT_TRUE(para1 != nullptr);
505 bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
506 EXPECT_TRUE(ret == true);
507
508 MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
509 ASSERT_TRUE(para2 != nullptr);
510 msgType = FSM_MSG_UNKNOWN;
511 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
512 EXPECT_TRUE(ret == true);
513
514 MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
515 ASSERT_TRUE(para3 != nullptr);
516 msgType = FSM_MSG_RECV_DEVICE_INFO;
517 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
518 EXPECT_TRUE(ret == true);
519 authFsm.info.isNodeInfoReceived = true;
520 HandleMsgRecvCloseAck(&authFsm, para1);
521 }
522
523 /*
524 * @tc.name: SYNC_DEV_ID_STATE_PROCESS_TEST_001
525 * @tc.desc: SyncDevIdStateProcess test
526 * @tc.type: FUNC
527 * @tc.require:
528 */
529 HWTEST_F(AuthSessionFsmTest, SYNC_DEV_ID_STATE_PROCESS_TEST_001, TestSize.Level1)
530 {
531 int32_t ret;
532 AuthFsm authFsm;
533 AuthSessionFsmInterfaceMock mock;
534 MessagePara *para = (MessagePara *)SoftBusCalloc(sizeof(MessagePara));
535 ASSERT_NE(para, nullptr);
536 authFsm.isDead = false;
537 (void)memset_s(&authFsm, sizeof(authFsm), 0, sizeof(authFsm));
538 (void)memset_s(para, sizeof(MessagePara), 0, sizeof(MessagePara));
539 ret = SyncDevIdStateProcess(&(authFsm.fsm), FSM_MSG_RECV_DEVICE_ID, para);
540 EXPECT_TRUE(ret);
541 para = (MessagePara *)SoftBusCalloc(sizeof(MessagePara));
542 ASSERT_NE(para, nullptr);
543 ret = SyncDevIdStateProcess(&(authFsm.fsm), FSM_MSG_DEVICE_POST_DEVICEID, para);
544 EXPECT_TRUE(ret);
545 para = (MessagePara *)SoftBusCalloc(sizeof(MessagePara));
546 ASSERT_NE(para, nullptr);
547 ret = SyncDevIdStateProcess(&(authFsm.fsm), FSM_MSG_UNKNOWN, para);
548 EXPECT_TRUE(ret);
549 }
550
551 /*
552 * @tc.name: GET_AUTH_FSM_BY_REQUEST_ID_TEST_001
553 * @tc.desc: GetAuthFsmByRequestId test
554 * @tc.type: FUNC
555 * @tc.require:
556 */
557 HWTEST_F(AuthSessionFsmTest, GET_AUTH_FSM_BY_REQUEST_ID_TEST_001, TestSize.Level1)
558 {
559 uint64_t requestId = TEST_REQUEST_ID;
560 AuthFsm * fsm = GetAuthFsmByRequestId(requestId);
561 EXPECT_EQ(fsm, nullptr);
562 }
563
564 /*
565 * @tc.name: IS_PEER_SUPPORT_NEGO_AUTH_TEST_001
566 * @tc.desc: IsPeerSupportNegoAuth test
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(AuthSessionFsmTest, IS_PEER_SUPPORT_NEGO_AUTH_TEST_001, TestSize.Level1)
571 {
572 AuthSessionInfo info;
573 AuthSessionFsmInterfaceMock mock;
574 EXPECT_CALL(mock, GetUdidShortHash).WillOnce(Return(false));
575 bool ret = IsPeerSupportNegoAuth(&info);
576 EXPECT_TRUE(ret);
577 EXPECT_CALL(mock, GetUdidShortHash).WillRepeatedly(Return(true));
578 EXPECT_CALL(mock, LnnRetrieveDeviceInfoPacked).WillOnce(Return(SOFTBUS_NOT_IMPLEMENT));
579 ret = IsPeerSupportNegoAuth(&info);
580 EXPECT_TRUE(ret);
581 EXPECT_CALL(mock, LnnRetrieveDeviceInfoPacked).WillRepeatedly(Return(SOFTBUS_OK));
582 EXPECT_CALL(mock, IsSupportFeatureByCapaBit).WillOnce(Return(true));
583 ret = IsPeerSupportNegoAuth(&info);
584 EXPECT_TRUE(ret);
585 EXPECT_CALL(mock, IsSupportFeatureByCapaBit).WillOnce(Return(false));
586 ret = IsPeerSupportNegoAuth(&info);
587 EXPECT_FALSE(ret);
588 }
589
590 /*
591 * @tc.name: GET_FIRST_FSM_TEST_001
592 * @tc.desc: GetFirstFsmState test
593 * @tc.type: FUNC
594 * @tc.require:
595 */
596 HWTEST_F(AuthSessionFsmTest, GET_FIRST_FSM_TEST_001, TestSize.Level1)
597 {
598 AuthSessionInfo info;
599 int64_t authSeq = AUTH_SEQ;
600 AuthFsmStateIndex state;
601 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
602 info.isConnectServer = true;
603 AuthSessionFsmInterfaceMock mock;
604 EXPECT_CALL(mock, GetUdidShortHash).WillRepeatedly(Return(false));
605 EXPECT_CALL(mock, LnnRetrieveDeviceInfoPacked).WillRepeatedly(Return(SOFTBUS_OK));
606 EXPECT_CALL(mock, IsSupportFeatureByCapaBit).WillRepeatedly(Return(true));
607 int32_t ret = GetFirstFsmState(&info, authSeq, &state);
608 EXPECT_EQ(ret, SOFTBUS_OK);
609 info.isConnectServer = false;
610 ret = GetFirstFsmState(&info, authSeq, &state);
611 EXPECT_EQ(ret, SOFTBUS_OK);
612 }
613
614 /*
615 * @tc.name: AUTH_SESSION_GET_CRED_ID_TEST_001
616 * @tc.desc: AuthSessionGetCredId test
617 * @tc.type: FUNC
618 * @tc.require:
619 */
620 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_GET_CRED_ID_TEST_001, TestSize.Level1)
621 {
622 int64_t authSeq = AUTH_SEQ;
623 char *credId = AuthSessionGetCredId(authSeq);
624 EXPECT_EQ(credId, nullptr);
625 }
626
627 /*
628 * @tc.name: AUTH_SESSION_GET_AUTH_VERSION_TEST_001
629 * @tc.desc:
630 * @tc.type: FUNC
631 * @tc.require:
632 */
633 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_GET_AUTH_VERSION_TEST_001, TestSize.Level1)
634 {
635 int64_t authSeq = AUTH_SEQ;
636 int32_t version = 0;
637 int32_t ret = AuthSessionGetAuthVersion(authSeq, nullptr);
638 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
639 ret = AuthSessionGetAuthVersion(authSeq, &version);
640 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_SESSION_INFO_FAIL);
641 }
642
643
644 /*
645 * @tc.name: AUTH_SESSION_GET_IS_SAME_TEST_001
646 * @tc.desc:
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_GET_IS_SAME_TEST_001, TestSize.Level1)
651 {
652 int64_t authSeq = AUTH_SEQ;
653 bool ret = AuthSessionGetIsSameAccount(authSeq);
654 EXPECT_FALSE(ret);
655 }
656
657 /*
658 * @tc.name: AUTH_SESSION_HANDLE_AUTH_ERROR_TEST_001
659 * @tc.desc:
660 * @tc.type: FUNC
661 * @tc.require:
662 */
663 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_HANDLE_AUTH_ERROR_TEST_001, TestSize.Level1)
664 {
665 int64_t authSeq = AUTH_SEQ;
666 int32_t reason = 0;
667 int32_t ret = AuthSessionHandleAuthError(authSeq, reason);
668 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_FSM_FAIL);
669 }
670
671 /*
672 * @tc.name: POPULATE_DEVICE_TYPE_ID_TEST_001
673 * @tc.desc: PopulateDeviceTypeId test
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(AuthSessionFsmTest, POPULATE_DEVICE_TYPE_ID_TEST_001, TestSize.Level1)
678 {
679 AuthSessionFsmInterfaceMock mock;
680 HiChainAuthParam authParam;
681 (void)memset_s(&authParam, sizeof(HiChainAuthParam), 0, sizeof(HiChainAuthParam));
682 uint32_t requestId = REQUEST_ID_1;
683 EXPECT_NO_FATAL_FAILURE(PopulateDeviceTypeId(&authParam, requestId));
684 ClearAuthRequest();
685 AuthRequest request;
686 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
687 request.authId = REQUEST_ID;
688 request.deviceTypeId = REQUEST_TYPE_RECONNECT;
689 EXPECT_TRUE(AddAuthRequest(&request) == SOFTBUS_OK);
690 requestId = REQUEST_ID;
691 EXPECT_CALL(mock, GetAuthRequest).WillOnce(Return(SOFTBUS_OK));
692 EXPECT_NO_FATAL_FAILURE(PopulateDeviceTypeId(&authParam, requestId));
693 }
694
695 /*
696 * @tc.name: POPULATE_DEVICE_TYPE_ID_TEST_002
697 * @tc.desc: PopulateDeviceTypeId test
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 HWTEST_F(AuthSessionFsmTest, POPULATE_DEVICE_TYPE_ID_TEST_002, TestSize.Level1)
702 {
703 AuthSessionFsmInterfaceMock mock;
704 HiChainAuthParam authParam;
705 (void)memset_s(&authParam, sizeof(HiChainAuthParam), 0, sizeof(HiChainAuthParam));
706 uint32_t requestId = REQUEST_ID_1;
707 EXPECT_NO_FATAL_FAILURE(PopulateDeviceTypeId(&authParam, requestId));
708 ClearAuthRequest();
709 AuthRequest request;
710 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
711 request.authId = REQUEST_ID;
712 request.deviceTypeId = TYPE_PC_ID;
713 EXPECT_TRUE(AddAuthRequest(&request) == SOFTBUS_OK);
714 requestId = REQUEST_ID;
715 EXPECT_CALL(mock, GetAuthRequest).WillOnce(DoAll(SetArgPointee<1>(request), Return(SOFTBUS_OK)));
716 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).Times(0);
717 EXPECT_CALL(mock, LnnRetrieveDeviceInfoPacked).Times(0);
718 EXPECT_NO_FATAL_FAILURE(PopulateDeviceTypeId(&authParam, requestId));
719 }
720
721 /*
722 * @tc.name: POPULATE_DEVICE_TYPE_ID_TEST_003
723 * @tc.desc: PopulateDeviceTypeId test
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(AuthSessionFsmTest, POPULATE_DEVICE_TYPE_ID_TEST_003, TestSize.Level1)
728 {
729 HiChainAuthParam authParam;
730 (void)memset_s(&authParam, sizeof(HiChainAuthParam), 0, sizeof(HiChainAuthParam));
731 uint32_t requestId = 123;
732 AuthRequest request;
733 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
734 request.deviceTypeId = 0;
735 NodeInfo infoPc;
736 infoPc.deviceInfo.deviceTypeId = TYPE_PC_ID;
737 NodeInfo infoOther;
738 infoOther.deviceInfo.deviceTypeId = 0;
739 AuthSessionFsmInterfaceMock mock;
740 EXPECT_CALL(mock, GetAuthRequest).WillOnce(DoAll(SetArgPointee<1>(request), Return(SOFTBUS_OK)));
741 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_NOT_FIND));
742 PopulateDeviceTypeId(&authParam, requestId);
743 EXPECT_NE(authParam.deviceTypeId, TYPE_PC_ID);
744 authParam.deviceTypeId = 0;
745 EXPECT_CALL(mock, GetAuthRequest).WillOnce(DoAll(SetArgPointee<1>(request), Return(SOFTBUS_OK)));
746 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillOnce(DoAll(SetArgPointee<2>(infoPc), Return(SOFTBUS_OK)));
747 PopulateDeviceTypeId(&authParam, requestId);
748 EXPECT_EQ(authParam.deviceTypeId, TYPE_PC_ID);
749 authParam.deviceTypeId = 0;
750 EXPECT_CALL(mock, GetAuthRequest).WillOnce(DoAll(SetArgPointee<1>(request), Return(SOFTBUS_NOT_FIND)));
751 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillOnce(DoAll(SetArgPointee<2>(infoOther), Return(SOFTBUS_OK)));
752 PopulateDeviceTypeId(&authParam, requestId);
753 EXPECT_NE(authParam.deviceTypeId, TYPE_PC_ID);
754 authParam.deviceTypeId = 0;
755 EXPECT_CALL(mock, GetAuthRequest).WillOnce(DoAll(SetArgPointee<1>(request), Return(SOFTBUS_NOT_FIND)));
756 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillOnce(DoAll(SetArgPointee<2>(infoOther), Return(SOFTBUS_OK)));
757 PopulateDeviceTypeId(&authParam, requestId);
758 EXPECT_EQ(authParam.deviceTypeId, 0);
759 }
760
761 /*
762 * @tc.name: HANDLE_MSG_RECV_DEVICE_ID_001
763 * @tc.desc: test HandleMsgRecvDeviceId
764 * @tc.type: FUNC
765 * @tc.require:
766 */
767 HWTEST_F(AuthSessionFsmTest, HANDLE_MSG_RECV_DEVICE_ID_001, TestSize.Level1)
768 {
769 AuthFsm authFsm;
770 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
771 MessagePara para;
772 (void)memset_s(¶, sizeof(MessagePara), 0, sizeof(MessagePara));
773 authFsm.authSeq = AUTH_SEQ_1;
774 authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
775 NiceMock<AuthSessionFsmInterfaceMock> mock;
776 EXPECT_CALL(mock, ProcessDeviceIdMessage).WillRepeatedly(Return(SOFTBUS_OK));
777 EXPECT_CALL(mock, PostDeviceInfoMessage).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
778 EXPECT_CALL(mock, LnnIsNeedInterceptBroadcast).WillOnce(Return(true)).WillOnce(Return(false));
779
780 authFsm.info.isServer = true;
781 EXPECT_NO_FATAL_FAILURE(HandleMsgRecvDeviceId(&authFsm, ¶));
782 EXPECT_NO_FATAL_FAILURE(HandleMsgRecvDeviceId(&authFsm, ¶));
783 }
784
785 /*
786 * @tc.name: HANDLE_MSG_RECV_DEVICE_ID_NDGO_001
787 * @tc.desc: test HandleMsgRecvDeviceIdNego
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(AuthSessionFsmTest, HANDLE_MSG_RECV_DEVICE_ID_NDGO_001, TestSize.Level1)
792 {
793 AuthFsm authFsm;
794 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
795 MessagePara para;
796 (void)memset_s(¶, sizeof(MessagePara), 0, sizeof(MessagePara));
797 authFsm.authSeq = AUTH_SEQ_1;
798 authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
799 NiceMock<AuthSessionFsmInterfaceMock> mock;
800 EXPECT_CALL(mock, ProcessDeviceIdMessage).WillRepeatedly(Return(SOFTBUS_OK));
801 EXPECT_CALL(mock, LnnIsNeedInterceptBroadcast).WillOnce(Return(true)).WillOnce(Return(false));
802
803 authFsm.info.isServer = true;
804 EXPECT_NO_FATAL_FAILURE(HandleMsgRecvDeviceIdNego(&authFsm, ¶));
805 EXPECT_NO_FATAL_FAILURE(HandleMsgRecvDeviceIdNego(&authFsm, ¶));
806 }
807 } // namespace OHOS