1 /*
2  * Copyright (c) 2022 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_common.h"
22 #include "auth_common_mock.h"
23 #include "auth_hichain.h"
24 #include "auth_interface.h"
25 #include "auth_log.h"
26 #include "auth_manager.h"
27 #include "auth_net_ledger_mock.h"
28 #include "auth_request.h"
29 #include "bus_center_adapter.h"
30 #include "lnn_connection_mock.h"
31 #include "lnn_hichain_mock.h"
32 #include "lnn_socket_mock.h"
33 #include "message_handler.h"
34 #include "softbus_access_token_test.h"
35 #include "softbus_adapter_bt_common.h"
36 #include "softbus_adapter_mem.h"
37 #include "softbus_errcode.h"
38 #include "softbus_feature_config.h"
39 #include "auth_session_message.h"
40 
41 namespace OHOS {
42 using namespace testing;
43 using namespace testing::ext;
44 #define TEST_UDID "123456ABCDEF"
45 #define TEST_UUID "6984321642"
46 #define DEV_NAME "DEVTEST"
47 #define TEST_MAC "11:22:33:44:55:66"
48 #define TEST_NETWORKID "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00"
49 #define VERSION_TYPE_LITE "LITE"
50 static const uint32_t REQUEST_ID = 88;
51 static const bool TEST_IS_P2P = false;
52 static const int64_t SEQ_SERVER = 3;
53 static const int32_t TEST_P2P_ROLE = 1;
54 static const uint32_t TEST_NET_CAPACITY = 3;
55 static const uint16_t TEST_DATA_CHANGE_FLAG = 1;
56 static const uint64_t TEST_SUP_PROTOCOLS = 453213535465;
57 static const ConnModule MODULE_ID = MODULE_DEVICE_AUTH;
58 static const uint8_t DEVICE_INFO[5] = { 0x10, 0x2, 0x14, 0x08, 0x06 };
59 uint8_t g_sessionKey[SESSION_KEY_LENGTH];
60 static const int32_t TEST_DATA_LEN = 600;
61 static const int OPER_CODE = 0;
62 static const int DELAY_TIME = 15;
63 static const char *g_retData = nullptr;
64 static uint64_t g_connId = 8590065691;
65 const AuthConnInfo g_connInfo = {
66     .type = AUTH_LINK_TYPE_BR,
67     .info.brInfo.brMac = TEST_MAC,
68     .peerUid = "002",
69 };
70 const AuthVerifyCallback callBack = {
71     .onVerifyPassed = LnnConnectInterfaceMock::OnVerifyPassed,
72     .onVerifyFailed = LnnConnectInterfaceMock::onVerifyFailed,
73 };
74 const AuthSessionInfo info = {
75     .isServer = true,
76     .connInfo = g_connInfo,
77 };
78 const AuthSessionInfo info2 = {
79     .isServer = false,
80     .connId = g_connId,
81     .connInfo = g_connInfo,
82 };
83 struct MockInterfaces {
84     LnnConnectInterfaceMock *connMock;
85     LnnHichainInterfaceMock *hichainMock;
86     AuthNetLedgertInterfaceMock *ledgerMock;
87     LnnSocketInterfaceMock *socketMock;
88     AuthCommonInterfaceMock *authMock;
89 };
90 AuthDataHead devIdHead = {
91     .dataType = DATA_TYPE_DEVICE_ID,
92     .module = MODULE_DEVICE_AUTH,
93     .seq = SEQ_SERVER,
94     .flag = SERVER_SIDE_FLAG,
95 };
96 AuthDataHead devAuthHead = {
97     .dataType = DATA_TYPE_AUTH,
98     .module = MODULE_DEVICE_AUTH,
99     .seq = SEQ_SERVER,
100     .flag = SERVER_SIDE_FLAG,
101 };
102 AuthDataHead devInfoAuthHead = {
103     .dataType = DATA_TYPE_DEVICE_INFO,
104     .module = MODULE_DEVICE_AUTH,
105     .seq = SEQ_SERVER,
106     .flag = SERVER_SIDE_FLAG,
107 };
108 AuthDataHead closeAckHead = {
109     .dataType = DATA_TYPE_CLOSE_ACK,
110     .module = MODULE_DEVICE_AUTH,
111     .seq = SEQ_SERVER,
112     .flag = SERVER_SIDE_FLAG,
113 };
114 AuthVerifyListener g_listener = {
115     .onDeviceVerifyPass = &AuthNetLedgertInterfaceMock::OnDeviceVerifyPass,
116     .onDeviceNotTrusted = &AuthNetLedgertInterfaceMock::OnDeviceNotTrusted,
117     .onDeviceDisconnect = &AuthNetLedgertInterfaceMock::OnDeviceDisconnect,
118 };
119 NodeInfo g_localInfo = {
120     .versionType = VERSION_TYPE_LITE,
121     .uuid = TEST_UUID,
122     .networkId = TEST_NETWORKID,
123     .netCapacity = TEST_NET_CAPACITY,
124     .isBleP2p = TEST_IS_P2P,
125     .p2pInfo.p2pMac = TEST_MAC,
126     .supportedProtocols = TEST_SUP_PROTOCOLS,
127     .dataChangeFlag = TEST_DATA_CHANGE_FLAG,
128 };
SendSignal()129 void SendSignal()
130 {
131     AUTH_LOGI(AUTH_TEST, "SendSignal");
132     if (SoftBusMutexLock(&LnnHichainInterfaceMock::mutex) != SOFTBUS_OK) {
133         AUTH_LOGE(AUTH_TEST, "SendSignal Lock failed");
134         return;
135     }
136     AuthNetLedgertInterfaceMock::isRuned = true;
137     (void)SoftBusCondSignal(&LnnHichainInterfaceMock::cond);
138     (void)SoftBusMutexUnlock(&LnnHichainInterfaceMock::mutex);
139     AUTH_LOGI(AUTH_TEST, "SendSignal end");
140 }
141 
ClientFSMCreate(MockInterfaces * mockInterface,GroupAuthManager & authManager,DeviceGroupManager & groupManager)142 void ClientFSMCreate(MockInterfaces *mockInterface, GroupAuthManager &authManager, DeviceGroupManager &groupManager)
143 {
144     bool isServer = false;
145     memset_s(g_localInfo.offlineCode, OFFLINE_CODE_BYTE_SIZE, 0, OFFLINE_CODE_BYTE_SIZE);
146     ON_CALL(*mockInterface->connMock, ConnConnectDevice(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
147     groupManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
148     groupManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
149     authManager.authDevice = LnnHichainInterfaceMock::InvokeAuthDevice;
150     ON_CALL(*mockInterface->connMock, ConnSetConnectCallback(_, _))
151         .WillByDefault(LnnConnectInterfaceMock::ActionofConnSetConnectCallback);
152     ON_CALL(*mockInterface->connMock, ConnGetHeadSize()).WillByDefault(Return(sizeof(ConnPktHead)));
153     ON_CALL(*mockInterface->hichainMock, InitDeviceAuthService()).WillByDefault(Return(0));
154     ON_CALL(*mockInterface->hichainMock, GetGaInstance()).WillByDefault(Return(&authManager));
155     ON_CALL(*mockInterface->hichainMock, GetGmInstance()).WillByDefault(Return(&groupManager));
156     ON_CALL(*mockInterface->ledgerMock, LnnGetLocalStrInfo).WillByDefault(Return(SOFTBUS_OK));
157     ON_CALL(*mockInterface->authMock, LnnAsyncCallbackDelayHelper(_, _, _, _)).WillByDefault(Return(SOFTBUS_OK));
158     int32_t ret = AuthInit();
159     EXPECT_TRUE(ret == SOFTBUS_OK);
160     ON_CALL(*mockInterface->connMock, ConnPostBytes).WillByDefault(Return(SOFTBUS_OK));
161     ON_CALL(*mockInterface->socketMock, ConnOpenClientSocket(_, _, _)).WillByDefault(Return(SOFTBUS_OK));
162     ON_CALL(*mockInterface->connMock, ConnGetConnectionInfo)
163         .WillByDefault(LnnConnectInterfaceMock::ActionofConnGetConnectionInfo);
164     ON_CALL(*mockInterface->ledgerMock, LnnGetDeviceName).WillByDefault(Return(DEV_NAME));
165     ON_CALL(*mockInterface->ledgerMock, LnnConvertIdToDeviceType).WillByDefault(Return(const_cast<char *>(TYPE_PAD)));
166     ON_CALL(*mockInterface->ledgerMock, LnnGetDeviceUdid).WillByDefault(Return(TEST_UDID));
167     ON_CALL(*mockInterface->ledgerMock, LnnGetP2pRole).WillByDefault(Return(TEST_P2P_ROLE));
168     ON_CALL(*mockInterface->ledgerMock, LnnGetP2pMac).WillByDefault(Return(TEST_MAC));
169     ON_CALL(*mockInterface->ledgerMock, LnnGetSupportedProtocols).WillByDefault(Return(TEST_SUP_PROTOCOLS));
170     ON_CALL(*mockInterface->ledgerMock, LnnGetLocalNodeInfo).WillByDefault(Return(&g_localInfo));
171     ON_CALL(*mockInterface->ledgerMock, LnnGetBtMac).WillByDefault(Return(TEST_MAC));
172     ON_CALL(*mockInterface->authMock, SoftBusGetBtState).WillByDefault(Return(BLE_ENABLE));
173     const unsigned char val = 0x01;
174     SoftbusSetConfig(SOFTBUS_INT_AUTH_ABILITY_COLLECTION, &val, sizeof(val));
175     ret = AuthStartVerify(&g_connInfo, REQUEST_ID, &callBack, AUTH_MODULE_LNN, true);
176 
177     EXPECT_TRUE(ret == SOFTBUS_OK);
178     AuthParam authInfo = {
179         .authSeq = SEQ_SERVER,
180         .requestId = REQUEST_ID,
181         .connId = g_connId,
182         .isServer = isServer,
183         .isFastAuth = false,
184     };
185     AuthSessionStartAuth(&authInfo, &g_connInfo);
186     SoftBusSleepMs(DELAY_TIME);
187 }
188 
WaitForSignal()189 bool WaitForSignal()
190 {
191 #define USECTONSEC 1000LL
192     SoftBusSysTime now;
193     if (SoftBusGetTime(&now) != SOFTBUS_OK) {
194         AUTH_LOGE(AUTH_TEST, "BrSoftBusCondWait SoftBusGetTime failed");
195         return SOFTBUS_ERR;
196     }
197     int64_t time = now.sec * USECTONSEC * USECTONSEC + now.usec + DELAY_TIME * USECTONSEC;
198     SoftBusSysTime tv;
199     tv.sec = time / USECTONSEC / USECTONSEC;
200     tv.usec = time % (USECTONSEC * USECTONSEC);
201     if (SoftBusMutexLock(&LnnHichainInterfaceMock::mutex) != SOFTBUS_OK) {
202         AUTH_LOGE(AUTH_TEST, "Wait signal Lock failed");
203         return false;
204     }
205     if (!AuthNetLedgertInterfaceMock::isRuned) {
206         int ret = SoftBusCondWait(&LnnHichainInterfaceMock::cond, &LnnHichainInterfaceMock::mutex, &tv);
207         (void)SoftBusMutexUnlock(&LnnHichainInterfaceMock::mutex);
208         return (ret == SOFTBUS_OK);
209     } else {
210         (void)SoftBusMutexUnlock(&LnnHichainInterfaceMock::mutex);
211         SoftBusSleepMs(DELAY_TIME);
212         AuthNetLedgertInterfaceMock::isRuned = false;
213     }
214     return true;
215 }
216 
CreateInfo(NodeInfo & nodeInfo)217 NodeInfo CreateInfo(NodeInfo &nodeInfo)
218 {
219     return nodeInfo;
220 }
221 
222 class AuthTestCallBackTest : public testing::Test {
223 public:
224     static void SetUpTestCase();
225     static void TearDownTestCase();
226     void SetUp();
227     void TearDown();
228 };
229 
SetUpTestCase()230 void AuthTestCallBackTest::SetUpTestCase()
231 {
232     AuthNetLedgertInterfaceMock::isRuned = false;
233     RegAuthVerifyListener(&g_listener);
234     (void)SoftBusMutexInit(&LnnHichainInterfaceMock::mutex, nullptr);
235     SoftBusCondInit(&LnnHichainInterfaceMock::cond);
236 }
237 
TearDownTestCase()238 void AuthTestCallBackTest::TearDownTestCase()
239 {
240     AuthNetLedgertInterfaceMock::isRuned = false;
241     SoftBusCondDestroy(&LnnHichainInterfaceMock::cond);
242     SoftBusMutexDestroy(&LnnHichainInterfaceMock::mutex);
243 }
244 
SetUp()245 void AuthTestCallBackTest::SetUp()
246 {
247     LooperInit();
248     AUTH_LOGI(AUTH_TEST, "AuthTestCallBackTest start.");
249 }
250 
TearDown()251 void AuthTestCallBackTest::TearDown()
252 {
253     LooperDeinit();
254 }
255 
AuthInitMock(LnnConnectInterfaceMock & connMock,LnnHichainInterfaceMock & hichainMock,GroupAuthManager authManager,DeviceGroupManager groupManager)256 void AuthInitMock(LnnConnectInterfaceMock &connMock, LnnHichainInterfaceMock &hichainMock, GroupAuthManager authManager,
257     DeviceGroupManager groupManager)
258 {
259     groupManager.regDataChangeListener = LnnHichainInterfaceMock::InvokeDataChangeListener;
260     authManager.authDevice = LnnHichainInterfaceMock::InvokeAuthDevice;
261     groupManager.unRegDataChangeListener = LnnHichainInterfaceMock::ActionofunRegDataChangeListener;
262     ON_CALL(connMock, ConnSetConnectCallback(_, _)).WillByDefault(Return(SOFTBUS_OK));
263     ON_CALL(hichainMock, InitDeviceAuthService()).WillByDefault(Return(0));
264     ON_CALL(hichainMock, GetGaInstance()).WillByDefault(Return(&authManager));
265     ON_CALL(hichainMock, GetGmInstance()).WillByDefault(Return(&groupManager));
266 }
267 
268 /*
269  * @tc.name: AUTH_CALLBACK_TEST_001
270  * @tc.desc: auth callback test
271  * @tc.type: FUNC
272  * @tc.require:
273  */
274 
275 HWTEST_F(AuthTestCallBackTest, AUTH_CALLBACK_TEST_001, TestSize.Level1)
276 {
277     GroupAuthManager authManager;
278     DeviceGroupManager groupManager;
279     NiceMock<LnnConnectInterfaceMock> connMock;
280     NiceMock<LnnHichainInterfaceMock> hichainMock;
281     NiceMock<AuthNetLedgertInterfaceMock> ledgerMock;
282     NiceMock<LnnSocketInterfaceMock> socketMock;
283     NiceMock<AuthCommonInterfaceMock> authMock;
284     MockInterfaces mockInterface = {
285         .connMock = &connMock,
286         .hichainMock = &hichainMock,
287         .ledgerMock = &ledgerMock,
288         .socketMock = &socketMock,
289         .authMock = &authMock,
290     };
291     AuthInitMock(connMock, hichainMock, authManager, groupManager);
292     ClientFSMCreate(&mockInterface, authManager, groupManager);
293     WaitForSignal();
294     char *data = AuthNetLedgertInterfaceMock::Pack(SEQ_SERVER, &info, devIdHead);
295     LnnConnectInterfaceMock::g_conncallback.OnDataReceived(g_connId, MODULE_ID, SEQ_SERVER, data, TEST_DATA_LEN);
296     authManager.processData = LnnHichainInterfaceMock::ActionOfProcessData;
297     HichainProcessData(SEQ_SERVER, DEVICE_INFO, TEST_DATA_LEN);
298     EXPECT_CALL(connMock, ConnPostBytes).WillRepeatedly(DoAll(SendSignal, Return(SOFTBUS_OK)));
299     LnnHichainInterfaceMock::g_devAuthCb.onTransmit(SEQ_SERVER, DEVICE_INFO, TEST_DATA_LEN);
300     EXPECT_TRUE(AuthNetLedgertInterfaceMock::isRuned == true);
301     WaitForSignal();
302     SoftBusFree(data);
303     char *data2 = AuthNetLedgertInterfaceMock::Pack(SEQ_SERVER, &info, devAuthHead);
304     LnnConnectInterfaceMock::g_conncallback.OnDataReceived(g_connId, MODULE_ID, SEQ_SERVER, data2, TEST_DATA_LEN);
305     WaitForSignal();
306     SoftBusFree(data2);
307     EXPECT_CALL(authMock, LnnGetNetworkIdByUuid).WillRepeatedly(Return(SOFTBUS_OK));
308     LnnHichainInterfaceMock::g_devAuthCb.onSessionKeyReturned(SEQ_SERVER, g_sessionKey, SESSION_KEY_LENGTH);
309     WaitForSignal();
310     EXPECT_CALL(connMock, ConnPostBytes).WillRepeatedly(DoAll(SendSignal, Return(SOFTBUS_OK)));
311     LnnHichainInterfaceMock::g_devAuthCb.onFinish(SEQ_SERVER, OPER_CODE, g_retData);
312     WaitForSignal();
313     EXPECT_CALL(connMock, ConnPostBytes).WillRepeatedly(DoAll(SendSignal,
314         LnnConnectInterfaceMock::ActionOfConnPostBytes));
315     PostDeviceInfoMessage(SEQ_SERVER, &info2);
316     WaitForSignal();
317     LnnConnectInterfaceMock::g_conncallback.OnDataReceived(g_connId, MODULE_ID, SEQ_SERVER,
318         LnnConnectInterfaceMock::g_encryptData, TEST_DATA_LEN);
319     WaitForSignal();
320     char *data4 = AuthNetLedgertInterfaceMock::Pack(SEQ_SERVER, &info, closeAckHead);
321     LnnConnectInterfaceMock::g_conncallback.OnDataReceived(g_connId, MODULE_ID, SEQ_SERVER, data4, TEST_DATA_LEN);
322     WaitForSignal();
323     SoftBusFree(data4);
324 }
325 } // namespace OHOS