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