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 "auth_common.h"
17 #include "auth_common_mock.h"
18 #include "auth_hichain.h"
19 #include "auth_interface.h"
20 #include "auth_log.h"
21 #include "auth_manager.h"
22 #include "auth_net_ledger_mock.h"
23 #include "auth_request.h"
24 #include "lnn_connection_fsm.h"
25
26 #include "lnn_hichain_mock.h"
27 #include "lnn_map.h"
28 #include "lnn_socket_mock.h"
29 #include "message_handler.h"
30 #include "softbus_access_token_test.h"
31 #include "softbus_adapter_bt_common.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_error_code.h"
34 #include "softbus_feature_config.h"
35 #include <cinttypes>
36 #include <gtest/gtest.h>
37 #include <securec.h>
38 #include <sys/time.h>
39
40 namespace OHOS {
41 using namespace testing;
42 using namespace testing::ext;
43
44 const AuthConnInfo g_connInfo = {
45 .type = AUTH_LINK_TYPE_BR,
46 .info.brInfo.brMac = "11:22:33:44:55:66",
47 .peerUid = "002",
48 };
49 const AuthConnInfo g_connInfo2 = {
50 .type = AUTH_LINK_TYPE_P2P,
51 .info.brInfo.brMac = "11:22:33:44:55:66",
52 .peerUid = "002",
53 };
54 uint32_t g_requestId = 88;
55 const AuthVerifyCallback g_callback = {
56 .onVerifyPassed = AuthCommonInterfaceMock::OnVerifyPassed,
57 .onVerifyFailed = AuthCommonInterfaceMock::OnVerifyFailed,
58 };
59
60 const AuthConnCallback g_connCallback = {
61 .onConnOpened = AuthCommonInterfaceMock::OnConnOpened,
62 .onConnOpenFailed = AuthCommonInterfaceMock::OnConnOpenFailed,
63 };
64 static const int32_t MILLIS = 15;
65 static constexpr int32_t DEFALUT_USERID = 100;
66
67 class AuthEnhanceMockTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
71 void SetUp();
72 void TearDown();
73 };
74
SetUpTestCase()75 void AuthEnhanceMockTest::SetUpTestCase()
76 {
77 SetAccessTokenPermission("AuthEnhanceMockTest");
78 AuthCommonInit();
79 }
80
TearDownTestCase()81 void AuthEnhanceMockTest::TearDownTestCase()
82 {
83 SoftBusSleepMs(MILLIS);
84 AuthCommonDeinit();
85 }
86
SetUp()87 void AuthEnhanceMockTest::SetUp()
88 {
89 AUTH_LOGI(AUTH_TEST, "AuthTest start.");
90 }
91
TearDown()92 void AuthEnhanceMockTest::TearDown() { }
93
AuthInitMock(AuthCommonInterfaceMock & connMock,LnnHichainInterfaceMock & hichainMock,GroupAuthManager & authManager,DeviceGroupManager & groupManager)94 void AuthInitMock(AuthCommonInterfaceMock &connMock, LnnHichainInterfaceMock &hichainMock,
95 GroupAuthManager &authManager, DeviceGroupManager &groupManager)
96 {
97 groupManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
98 authManager.authDevice = LnnHichainInterfaceMock::InvokeAuthDevice;
99 groupManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
100 ON_CALL(connMock, ConnSetConnectCallback(_, _)).WillByDefault(Return(SOFTBUS_OK));
101 ON_CALL(hichainMock, InitDeviceAuthService()).WillByDefault(Return(0));
102 ON_CALL(hichainMock, GetGaInstance()).WillByDefault(Return(&authManager));
103 ON_CALL(hichainMock, GetGmInstance()).WillByDefault(Return(&groupManager));
104 }
105
106 /*
107 * @tc.name: AUTH_START_LISTENING_Test_001
108 * @tc.desc: auth start listening
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(AuthEnhanceMockTest, AUTH_START_LISTENING_Test_001, TestSize.Level0)
113 {
114 int32_t port = 5566;
115 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_P2P, nullptr, port);
116 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
117 ret = AuthStartListening(AUTH_LINK_TYPE_P2P, "192.168.78.1", port);
118 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
119 }
120
121 /*
122 * @tc.name: AUTH_HICHAIN_START_AUTH_Test_001
123 * @tc.desc: hichain start auth
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(AuthEnhanceMockTest, AUTH_HICHAIN_START_AUTH_Test_001, TestSize.Level0)
128 {
129 const char *udid = "1111222233334444";
130 const char *uid = "8888";
131 int64_t authSeq = 5678;
132 NiceMock<AuthCommonInterfaceMock> connMock;
133 NiceMock<LnnHichainInterfaceMock> hichainMock;
134 GroupAuthManager authManager;
135 DeviceGroupManager groupManager;
136 AuthInitMock(connMock, hichainMock, authManager, groupManager);
137 ON_CALL(hichainMock, GetLnnTriggerInfo(_)).WillByDefault(Return());
138 int32_t ret = HichainStartAuth(authSeq, udid, uid, DEFALUT_USERID);
139 EXPECT_TRUE(ret == SOFTBUS_OK);
140 }
141
142 /*
143 * @tc.name: AUTH_INIT_Test_001
144 * @tc.desc: auth init
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(AuthEnhanceMockTest, AUTH_INIT_Test_001, TestSize.Level0)
149 {
150 NiceMock<AuthCommonInterfaceMock> connMock;
151 NiceMock<LnnHichainInterfaceMock> hichainMock;
152 GroupAuthManager authManager;
153 DeviceGroupManager groupManager;
154 NiceMock<AuthCommonInterfaceMock> commMock;
155 AuthInitMock(connMock, hichainMock, authManager, groupManager);
156 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
157 int32_t ret = AuthInit();
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159 }
160
161 /*
162 * @tc.name: AUTH_START_VERIFY_Test_001
163 * @tc.desc: client auth start verify ble
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_001, TestSize.Level1)
168 {
169 NiceMock<AuthCommonInterfaceMock> connMock;
170 NiceMock<LnnHichainInterfaceMock> hichainMock;
171 NiceMock<LnnSocketInterfaceMock> socketMock;
172 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
173 NiceMock<AuthCommonInterfaceMock> commMock;
174 GroupAuthManager authManager;
175 DeviceGroupManager groupManager;
176 AuthInitMock(connMock, hichainMock, authManager, groupManager);
177 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
178 int32_t ret = AuthInit();
179 EXPECT_EQ(ret, SOFTBUS_OK);
180 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
181 ON_CALL(connMock, ConnConnectDevice(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
182 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
183 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
184 ret = AuthStartVerify(&g_connInfo, g_requestId, &g_callback, AUTH_MODULE_LNN, true);
185 SoftBusSleepMs(MILLIS);
186 EXPECT_EQ(ret, SOFTBUS_OK);
187 ret = AuthStartConnVerify(&g_connInfo, g_requestId, &g_connCallback, AUTH_MODULE_TRANS, true);
188 SoftBusSleepMs(MILLIS);
189 EXPECT_EQ(ret, SOFTBUS_OK);
190 }
191
192 /*
193 * @tc.name: AUTH_START_VERIFY_Test_002
194 * @tc.desc: client auth start verify wifi
195 * @tc.type: FUNC
196 * @tc.require:
197 */
198 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_002, TestSize.Level1)
199 {
200 NiceMock<AuthCommonInterfaceMock> connMock;
201 NiceMock<LnnHichainInterfaceMock> hichainMock;
202 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
203 NiceMock<AuthCommonInterfaceMock> commMock;
204 NiceMock<LnnSocketInterfaceMock> socketMock;
205 GroupAuthManager authManager;
206 DeviceGroupManager groupManager;
207 AuthInitMock(connMock, hichainMock, authManager, groupManager);
208 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
209 int32_t ret = AuthInit();
210 EXPECT_EQ(ret, SOFTBUS_OK);
211 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
212 ON_CALL(connMock, ConnConnectDevice(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
213 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(2));
214 ON_CALL(socketMock, ConnSetTcpKeepalive(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
215 ON_CALL(socketMock, ConnShutdownSocket(_));
216 ret = AuthStartVerify(&g_connInfo2, g_requestId, &g_callback, AUTH_MODULE_LNN, true);
217 SoftBusSleepMs(MILLIS);
218 EXPECT_EQ(ret, SOFTBUS_OK);
219 ret = AuthStartConnVerify(&g_connInfo2, g_requestId, &g_connCallback, AUTH_MODULE_LNN, true);
220 SoftBusSleepMs(MILLIS);
221 EXPECT_EQ(ret, SOFTBUS_OK);
222 }
223
224 /*
225 * @tc.name: POST_DEVICEID_001
226 * @tc.desc: client auth start verify failed callback
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 HWTEST_F(AuthEnhanceMockTest, CLINET_CONN_FAILED_001, TestSize.Level1)
231 {
232 NiceMock<AuthCommonInterfaceMock> connMock;
233 NiceMock<LnnHichainInterfaceMock> hichainMock;
234 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
235 NiceMock<LnnSocketInterfaceMock> socketMock;
236 NiceMock<AuthCommonInterfaceMock> commMock;
237 GroupAuthManager authManager;
238 DeviceGroupManager groupManager;
239 AuthInitMock(connMock, hichainMock, authManager, groupManager);
240 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
241 int32_t ret = AuthInit();
242 EXPECT_EQ(ret, SOFTBUS_OK);
243 ON_CALL(connMock, ConnSetConnectCallback(_, _))
244 .WillByDefault(AuthCommonInterfaceMock::ActionofConnSetConnectCallback);
245 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
246 ON_CALL(connMock, ConnConnectDevice(_, _, NotNull()))
247 .WillByDefault(AuthCommonInterfaceMock::ActionofOnConnectFailed);
248 ON_CALL(connMock, ConnPostBytes(_, _)).WillByDefault(Return(SOFTBUS_OK));
249 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
250 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
251 ret = AuthStartVerify(&g_connInfo, g_requestId, &g_callback, AUTH_MODULE_LNN, true);
252 EXPECT_EQ(ret, SOFTBUS_OK);
253 SoftBusSleepMs(MILLIS);
254 }
255
256 /*
257 * @tc.name: AUTH_START_VERIFY_Test_003
258 * @tc.desc: client auth start verify success callback
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(AuthEnhanceMockTest, CLINET_AUTH_START_VERIFY_Test_003, TestSize.Level1)
263 {
264 NiceMock<AuthCommonInterfaceMock> connMock;
265 NiceMock<LnnHichainInterfaceMock> hichainMock;
266 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
267 NiceMock<LnnSocketInterfaceMock> socketMock;
268 NiceMock<AuthCommonInterfaceMock> commMock;
269 GroupAuthManager authManager;
270 DeviceGroupManager groupManager;
271 NodeInfo *info = { 0 };
272 AuthInitMock(connMock, hichainMock, authManager, groupManager);
273 ON_CALL(commMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
274 int32_t ret = AuthInit();
275 EXPECT_TRUE(ret == SOFTBUS_OK);
276 ON_CALL(connMock, ConnSetConnectCallback(_, _))
277 .WillByDefault(AuthCommonInterfaceMock::ActionofConnSetConnectCallback);
278 ON_CALL(ledgermock, LnnGetLocalStrInfo(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
279 ON_CALL(ledgermock, LnnGetLocalNodeInfo).WillByDefault(Return(info));
280 ON_CALL(connMock, ConnConnectDevice(_, _, NotNull()))
281 .WillByDefault(AuthCommonInterfaceMock::ActionofOnConnectSuccessed);
282 ON_CALL(connMock, ConnPostBytes(_, _)).WillByDefault(Return(SOFTBUS_OK));
283 ON_CALL(socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
284 ON_CALL(commMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
285 ret = AuthStartVerify(&g_connInfo, g_requestId, &g_callback, AUTH_MODULE_LNN, true);
286 EXPECT_TRUE(ret == SOFTBUS_OK);
287 SoftBusSleepMs(MILLIS);
288 }
289
290 /*
291 * @tc.name: CHECK_SESSIONKEY_VALID_Test_001
292 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSIONKEY_VALID_Test_001, TestSize.Level1)
297 {
298 AuthConnInfo connInfo;
299 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
300 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
301 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
302 NodeInfo node;
303 (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
304 EXPECT_NE(AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo), SOFTBUS_OK);
305 node.authCapacity = BIT_SUPPORT_NORMALIZED_LINK << 1;
306 ON_CALL(ledgermock, LnnGetRemoteNodeInfoById(_, _, _))
307 .WillByDefault(DoAll(SetArgPointee<2>(node), Return(SOFTBUS_OK)));
308 EXPECT_NE(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_OK);
309 }
310
311 /*
312 * @tc.name: CHECK_SESSIONKEY_VALID_Test_002
313 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSIONKEY_VALID_Test_002, TestSize.Level1)
318 {
319 char udidHash[UDID_HASH_LEN] = { 0 };
320 int64_t authSeq = 1;
321 int32_t keyLen = 32;
322 AuthSessionInfo info;
323 AuthConnInfo connInfo;
324 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
325 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
326 info.connInfo.type = AUTH_LINK_TYPE_BLE;
327 connInfo.type = AUTH_LINK_TYPE_BLE;
328 ASSERT_TRUE(memcpy_s(info.connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
329 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
330 EXPECT_EQ(AuthDirectOnlineCreateAuthManager(authSeq, &info), SOFTBUS_OK);
331
332 NiceMock<AuthNetLedgertInterfaceMock> ledgermock;
333 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
334 NodeInfo node;
335 (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
336 node.authCapacity = BIT_SUPPORT_NORMALIZED_LINK << 1;
337 ON_CALL(ledgermock, LnnGetRemoteNodeInfoById(_, _, _))
338 .WillByDefault(DoAll(SetArgPointee<2>(node), Return(SOFTBUS_OK)));
339 EXPECT_EQ(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_AUTH_SESSION_KEY_INVALID);
340 SessionKey sessionKey;
341 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
342 sessionKey.len = keyLen;
343 EXPECT_EQ(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, true, false), SOFTBUS_OK);
344 EXPECT_EQ(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo), SOFTBUS_OK);
345 }
346
347 /*
348 * @tc.name: CHECK_SESSION_KEY_VALID_BY_AUTH_HANDLE_Test_001
349 * @tc.desc: AuthCheckSessionKeyValidByAuthHandle test
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(AuthEnhanceMockTest, CHECK_SESSION_KEY_VALID_BY_AUTH_HANDLE_Test_001, TestSize.Level1)
354 {
355 char udidHash[UDID_HASH_LEN] = { 0 };
356 int64_t authSeq = 1;
357 int32_t keyLen = 32;
358 AuthSessionInfo info;
359 AuthConnInfo connInfo;
360 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
361 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
362 info.connInfo.type = AUTH_LINK_TYPE_BLE;
363 connInfo.type = AUTH_LINK_TYPE_BLE;
364 ASSERT_TRUE(memcpy_s(info.connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
365 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) == EOK);
366 EXPECT_EQ(AuthDirectOnlineCreateAuthManager(authSeq, &info), SOFTBUS_OK);
367 AuthHandle authHandle = { .authId = authSeq, .type = connInfo.type };
368 SessionKey sessionKey;
369 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
370 sessionKey.len = keyLen;
371 EXPECT_EQ(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, true, false), SOFTBUS_OK);
372 EXPECT_EQ(AuthCheckSessionKeyValidByAuthHandle(&authHandle), SOFTBUS_OK);
373 }
374 } // namespace OHOS
375