1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "auth_session_json.c"
20 #include "auth_session_json_mock.h"
21 #include "softbus_adapter_errcode.h"
22
23 namespace OHOS {
24 using namespace testing;
25 using namespace testing::ext;
26 constexpr int32_t PEER_IRK_LEN = 13;
27 constexpr int32_t PUBLIC_ADDRESS_LEN = 4;
28 constexpr int32_t CAPABILITY_LEN = 16;
29 constexpr int32_t DATA_TEST_LEN = 7;
30 constexpr int32_t TEST_DATA_LEN = 9;
31 constexpr int32_t TEST_FD = 123;
32 constexpr char DEVICE_KEY[SESSION_KEY_LENGTH] = "11111";
33 constexpr char UDID[UDID_BUF_LEN] = "123456789udidtest";
34 constexpr char UUID_TEST[UUID_BUF_LEN] = "123456789uuidtest";
35 constexpr char INVALID_UDID[UDID_BUF_LEN] = "\0";
36 constexpr char NETWORK_ID_TEST[NETWORK_ID_BUF_LEN] = "987654321";
37 constexpr char UNIFIED_NAME[DEVICE_NAME_BUF_LEN] = "unifiedName";
38 constexpr char INVALID_UNIFIED_NAME[DEVICE_NAME_BUF_LEN] = "\0";
39 constexpr char DEVICE_NAME_TEST[DEVICE_NAME_BUF_LEN] = "deviceName";
40 constexpr char IV_TEST[BROADCAST_IV_LEN] = "123456ivtest";
41 constexpr uint8_t PEER_IRK[LFINDER_IRK_LEN] = "123456irktest";
42 constexpr unsigned char PUBLIC_ADDRESS[LFINDER_MAC_ADDR_LEN] = "addr";
43 constexpr uint8_t STATIC_CAPABILITY[STATIC_CAP_LEN] = "staticCapability";
44 constexpr char REMOTE_PTK[PTK_DEFAULT_LEN] = "remotePtktest";
45 constexpr char KEY_TEST[SESSION_KEY_LENGTH] = "123456keytest";
46 constexpr char TEST_DATA[] = "testdata";
47
48 class AuthSessionJsonTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54 };
55
SetUpTestCase()56 void AuthSessionJsonTest::SetUpTestCase()
57 {
58 int32_t ret = AuthCommonInit();
59 EXPECT_EQ(ret, SOFTBUS_OK);
60 }
61
TearDownTestCase()62 void AuthSessionJsonTest::TearDownTestCase()
63 {
64 AuthCommonDeinit();
65 }
66
SetUp()67 void AuthSessionJsonTest::SetUp() { }
68
TearDown()69 void AuthSessionJsonTest::TearDown() { }
70
71 /*
72 @tc.name: PackFastAuthValue_TEST_001
73 @tc.desc: Quickly package authentication values test
74 @tc.type: FUNC
75 @tc.require:
76 */
77 HWTEST_F(AuthSessionJsonTest, PackFastAuthValue_TEST_001, TestSize.Level1)
78 {
79 JsonObj *json = JSON_CreateObject();
80 EXPECT_NE(json, nullptr);
81 char target[10] = { 0 };
82 JSON_AddStringToObject(json, FAST_AUTH, "jsontest");
83 OptString(json, DEVICE_ID, target, 10, "");
84 OptString(json, FAST_AUTH, target, 10, "");
85 int32_t val = 0;
86 OptInt(json, P2P_ROLE, &val, 0);
87 JSON_AddInt32ToObject(json, SOFTBUS_VERSION_TAG, 123);
88 OptInt(json, SOFTBUS_VERSION_TAG, &val, 0);
89 int64_t value = 0;
90 OptInt64(json, NEW_CONN_CAP, &value, 1);
91 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
92 OptInt64(json, NEW_CONN_CAP, &value, 1);
93 bool result;
94 OptBool(json, BLE_P2P, &result, false);
95 JSON_AddBoolToObject(json, BLE_P2P, true);
96 OptBool(json, BLE_P2P, &result, false);
97 JSON_Delete(json);
98 JsonObj *obj = JSON_CreateObject();
99 EXPECT_NE(obj, nullptr);
100 AuthDeviceKeyInfo deviceCommKey;
101 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
102 EXPECT_EQ(memcpy_s(deviceCommKey.deviceKey, SESSION_KEY_LENGTH, DEVICE_KEY, strlen(DEVICE_KEY)), EOK);
103 deviceCommKey.keyLen = 5;
104 deviceCommKey.keyIndex = 12345;
105 AuthSessionJsonInterfaceMock mock;
106 EXPECT_CALL(mock, LnnEncryptAesGcm).WillOnce(Return(SOFTBUS_ENCRYPT_ERR));
107 int32_t ret = PackFastAuthValue(obj, &deviceCommKey);
108 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
109 EXPECT_CALL(mock, LnnEncryptAesGcm).WillOnce(Return(SOFTBUS_OK));
110 ret = PackFastAuthValue(obj, &deviceCommKey);
111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
112 uint8_t *data = (uint8_t *)SoftBusCalloc(TEST_DATA_LEN);
113 ASSERT_TRUE(data != nullptr);
114 ret = memcpy_s(data, TEST_DATA_LEN, TEST_DATA, TEST_DATA_LEN);
115 EXPECT_EQ(ret, EOK);
116 EXPECT_CALL(mock, LnnEncryptAesGcm).WillOnce(DoAll(SetArgPointee<2>(data), Return(SOFTBUS_OK)));
117 ret = PackFastAuthValue(obj, &deviceCommKey);
118 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
119 JSON_Delete(obj);
120 }
121
122 /*
123 @tc.name: GetUdidOrShortHash_TEST_001
124 @tc.desc: Get udid or short hash interface test
125 @tc.type: FUNC
126 @tc.require:
127 */
128 HWTEST_F(AuthSessionJsonTest, GetUdidOrShortHash_TEST_001, TestSize.Level1)
129 {
130 AuthSessionInfo info;
131 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
132 info.isServer = false;
133 info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
134 ASSERT_TRUE(memcpy_s(info.connInfo.info.ipInfo.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
135 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
136 AuthSessionJsonInterfaceMock mock;
137 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_ENCRYPT_ERR));
138 bool ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
139 EXPECT_EQ(ret, false);
140 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
141 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
142 EXPECT_EQ(ret, true);
143 info.connInfo.type = AUTH_LINK_TYPE_SESSION;
144 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
145 EXPECT_EQ(ret, true);
146 info.isServer = true;
147 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
148 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
149 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
150 EXPECT_EQ(ret, true);
151 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
152 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, INVALID_UDID, strlen(INVALID_UDID)) == EOK);
153 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
154 EXPECT_EQ(ret, false);
155 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
156 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
157 EXPECT_EQ(ret, false);
158 info.connInfo.type = AUTH_LINK_TYPE_BLE;
159 ret = GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN);
160 EXPECT_EQ(ret, true);
161 }
162
163 /*
164 @tc.name: VerifySessionInfoIdType_TEST_001
165 @tc.desc: Verify session information id type interface test
166 @tc.type: FUNC
167 @tc.require:
168 */
169 HWTEST_F(AuthSessionJsonTest, VerifySessionInfoIdType_TEST_001, TestSize.Level1)
170 {
171 AuthSessionInfo info;
172 const char *encryptedFastAuth = "encryptedFastAuth";
173 AuthDeviceKeyInfo deviceKey;
174 (void)memset_s(&deviceKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
175 ASSERT_TRUE(memcpy_s(deviceKey.deviceKey, SESSION_KEY_LENGTH, DEVICE_KEY, strlen(DEVICE_KEY)) == EOK);
176 deviceKey.keyLen = 5;
177 deviceKey.keyIndex = 12345;
178 AuthSessionJsonInterfaceMock mock;
179 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
180 EXPECT_CALL(mock, IsPotentialTrustedDevice).WillRepeatedly(Return(true));
181 EXPECT_CALL(mock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
182 EXPECT_CALL(mock, IsFeatureSupport).WillRepeatedly(Return(true));
183 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
184 EXPECT_CALL(mock, AuthFindDeviceKey).WillRepeatedly(Return(SOFTBUS_OK));
185 ParseFastAuthValue(&info, encryptedFastAuth, &deviceKey);
186 JsonObj *obj = JSON_CreateObject();
187 EXPECT_NE(obj, nullptr);
188 JSON_AddStringToObject(obj, FAST_AUTH, encryptedFastAuth);
189 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
190 EXPECT_EQ(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)), EOK);
191 info.connInfo.type = AUTH_LINK_TYPE_BLE;
192 UnpackFastAuth(obj, &info);
193 info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
194 UnpackFastAuth(obj, &info);
195 NodeInfo nodeInfo;
196 nodeInfo.feature = 127;
197 PackCompressInfo(obj, &nodeInfo);
198 nodeInfo.feature = 0;
199 PackCompressInfo(obj, &nodeInfo);
200 PackWifiSinglePassInfo(obj, &info);
201 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
202 PackWifiSinglePassInfo(obj, &info);
203 info.idType = EXCHANGE_NETWORKID;
204 bool ret = VerifySessionInfoIdType(&info, obj, const_cast<char *>(NETWORK_ID_TEST), const_cast<char *>(UDID));
205 EXPECT_EQ(ret, true);
206 info.idType = EXCHANGE_UDID;
207 ret = VerifySessionInfoIdType(&info, obj, const_cast<char *>(NETWORK_ID_TEST), const_cast<char *>(UDID));
208 EXPECT_EQ(ret, true);
209 JSON_Delete(obj);
210 }
211
212 /*
213 @tc.name: PackDeviceIdJson_TEST_001
214 @tc.desc: Device id json pack interface test
215 @tc.type: FUNC
216 @tc.require:
217 */
218 HWTEST_F(AuthSessionJsonTest, PackDeviceIdJson_TEST_001, TestSize.Level1)
219 {
220 AuthSessionInfo info;
221 NodeInfo nodeInfo;
222 int64_t authSeq = 1;
223 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
224 info.version = SOFTBUS_OLD_V1;
225 info.idType = EXCHANGE_UDID;
226 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
227 info.isServer = true;
228 char *deviceId = PackDeviceIdJson(nullptr, authSeq);
229 EXPECT_EQ(deviceId, nullptr);
230 AuthSessionJsonInterfaceMock mock;
231 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
232 deviceId = PackDeviceIdJson(&info, authSeq);
233 EXPECT_EQ(deviceId, nullptr);
234 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
235 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
236 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
237 EXPECT_CALL(mock, FindAuthPreLinkNodeById).WillRepeatedly(Return(SOFTBUS_OK));
238 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(&nodeInfo));
239 EXPECT_CALL(mock, IsFeatureSupport).WillRepeatedly(Return(true));
240 EXPECT_CALL(mock, IsSupportFeatureByCapaBit).WillRepeatedly(Return(true));
241 EXPECT_CALL(mock, IsSupportUDIDAbatement).WillRepeatedly(Return(true));
242 EXPECT_CALL(mock, IsNeedUDIDAbatement).WillRepeatedly(Return(true));
243 deviceId = PackDeviceIdJson(&info, authSeq);
244 EXPECT_NE(deviceId, nullptr);
245 JSON_Free(deviceId);
246 info.isServer = false;
247 deviceId = PackDeviceIdJson(&info, authSeq);
248 EXPECT_NE(deviceId, nullptr);
249 JSON_Free(deviceId);
250 info.connInfo.type = AUTH_LINK_TYPE_BR;
251 deviceId = PackDeviceIdJson(&info, authSeq);
252 EXPECT_NE(deviceId, nullptr);
253 JSON_Free(deviceId);
254 }
255
256 /*
257 @tc.name: UnpackWifiSinglePassInfo_TEST_001
258 @tc.desc: Unpack of WiFi single channel information test
259 @tc.type: FUNC
260 @tc.require:
261 */
262 HWTEST_F(AuthSessionJsonTest, UnpackWifiSinglePassInfo_TEST_001, TestSize.Level1)
263 {
264 AuthSessionInfo info;
265 info.connInfo.type = AUTH_LINK_TYPE_BR;
266 info.connId = 12;
267 JsonObj *obj = JSON_CreateObject();
268 EXPECT_NE(obj, nullptr);
269 JSON_AddStringToObject(obj, FAST_AUTH, "encryptedFastAuth");
270 bool ret = UnpackWifiSinglePassInfo(obj, &info);
271 EXPECT_EQ(ret, true);
272 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
273 AuthSessionJsonInterfaceMock mock;
274 EXPECT_CALL(mock, GetFd).WillRepeatedly(Return(TEST_FD));
275 ret = UnpackWifiSinglePassInfo(obj, &info);
276 EXPECT_EQ(ret, true);
277 SoftBusSockAddr addr;
278 addr.saFamily = SOFTBUS_AF_INET;
279 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillRepeatedly(DoAll(SetArgPointee<1>(addr), Return(SOFTBUS_OK)));
280 ret = UnpackWifiSinglePassInfo(obj, &info);
281 EXPECT_EQ(ret, true);
282 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_OK));
283 ret = UnpackWifiSinglePassInfo(obj, &info);
284 EXPECT_EQ(ret, true);
285 JSON_AddStringToObject(obj, DEV_IP_HASH_TAG, "12345678");
286 ret = UnpackWifiSinglePassInfo(obj, &info);
287 EXPECT_EQ(ret, false);
288 JSON_Delete(obj);
289 }
290
291 /*
292 @tc.name: SetExchangeIdTypeAndValue_TEST_001
293 @tc.desc: Set Exchange Id type and value test
294 @tc.type: FUNC
295 @tc.require:
296 */
297 HWTEST_F(AuthSessionJsonTest, SetExchangeIdTypeAndValue_TEST_001, TestSize.Level1)
298 {
299 JsonObj *obj1 = JSON_CreateObject();
300 EXPECT_NE(obj1, nullptr);
301 AuthSessionInfo info;
302 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
303 info.idType = EXCHANGE_UDID;
304 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
305 int32_t ret = SetExchangeIdTypeAndValue(nullptr, &info);
306 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
307 ret = SetExchangeIdTypeAndValue(obj1, nullptr);
308 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
309 ret = SetExchangeIdTypeAndValue(obj1, &info);
310 EXPECT_EQ(ret, SOFTBUS_OK);
311 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
312 ret = SetExchangeIdTypeAndValue(obj1, &info);
313 EXPECT_EQ(ret, SOFTBUS_OK);
314 JSON_Delete(obj1);
315 JsonObj *obj2 = JSON_CreateObject();
316 EXPECT_NE(obj2, nullptr);
317 JSON_AddInt32ToObject(obj2, EXCHANGE_ID_TYPE, EXCHANGE_NETWORKID);
318 info.isServer = true;
319 AuthSessionJsonInterfaceMock mock;
320 EXPECT_CALL(mock, LnnRetrieveDeviceInfoByNetworkId).WillRepeatedly(Return(SOFTBUS_OK));
321 ret = SetExchangeIdTypeAndValue(obj2, &info);
322 EXPECT_EQ(ret, SOFTBUS_OK);
323 info.isServer = false;
324 ret = SetExchangeIdTypeAndValue(obj2, &info);
325 EXPECT_EQ(ret, SOFTBUS_OK);
326 info.idType = EXCHANGE_NETWORKID;
327 ret = SetExchangeIdTypeAndValue(obj2, &info);
328 EXPECT_EQ(ret, SOFTBUS_OK);
329 JSON_Delete(obj2);
330 JsonObj *obj3 = JSON_CreateObject();
331 EXPECT_NE(obj3, nullptr);
332 JSON_AddInt32ToObject(obj3, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
333 ret = SetExchangeIdTypeAndValue(obj3, &info);
334 EXPECT_EQ(ret, SOFTBUS_OK);
335 JSON_Delete(obj3);
336 }
337
338 /*
339 @tc.name: UnpackDeviceIdJson_TEST_001
340 @tc.desc: Device IdJson unpack test
341 @tc.type: FUNC
342 @tc.require:
343 */
344 HWTEST_F(AuthSessionJsonTest, UnpackDeviceIdJson_TEST_001, TestSize.Level1)
345 {
346 int64_t authSeq = 1;
347 JsonObj *obj = JSON_CreateObject();
348 EXPECT_NE(obj, nullptr);
349 AuthSessionInfo info;
350 int32_t ret = UnpackDeviceIdJson(nullptr, 0, &info, authSeq);
351 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
352 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
353 char *msg = JSON_PrintUnformatted(obj);
354 ret = UnpackDeviceIdJson(msg, strlen(msg), &info, authSeq);
355 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
356 if (msg != nullptr) {
357 JSON_Free(msg);
358 }
359 JSON_Delete(obj);
360 JsonObj *obj1 = JSON_CreateObject();
361 EXPECT_NE(obj1, nullptr);
362 JSON_AddStringToObject(obj1, CMD_TAG, CMD_GET_AUTH_INFO);
363 JSON_AddStringToObject(obj1, DATA_TAG, "123456");
364 JSON_AddStringToObject(obj1, DEVICE_ID_TAG, "654321");
365 JSON_AddInt32ToObject(obj1, DATA_BUF_SIZE_TAG, PACKET_SIZE);
366 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
367 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
368 JSON_AddStringToObject(obj1, SUPPORT_INFO_COMPRESS, TRUE_STRING_TAG);
369 char *msg1 = JSON_PrintUnformatted(obj1);
370 info.connInfo.type = AUTH_LINK_TYPE_BR;
371 ret = UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq);
372 EXPECT_EQ(ret, SOFTBUS_CMP_FAIL);
373 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
374 info.isServer = false;
375 ret = UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq);
376 EXPECT_EQ(ret, SOFTBUS_CMP_FAIL);
377 info.isConnectServer = true;
378 ret = UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq);
379 EXPECT_EQ(ret, SOFTBUS_OK);
380 if (msg1 != nullptr) {
381 JSON_Free(msg1);
382 }
383 JSON_Delete(obj1);
384 }
385
386 /*
387 @tc.name: PackCommonDevInfo_TEST_001
388 @tc.desc: Common Device information pack interface test
389 @tc.type: FUNC
390 @tc.require:
391 */
392 HWTEST_F(AuthSessionJsonTest, PackCommonDevInfo_TEST_001, TestSize.Level1)
393 {
394 JsonObj *json = JSON_CreateObject();
395 EXPECT_NE(json, nullptr);
396 NodeInfo info;
397 AuthSessionJsonInterfaceMock mock;
398 EXPECT_CALL(mock, LnnGetDeviceName).WillRepeatedly(Return(nullptr));
399 EXPECT_CALL(mock, LnnGetUnifiedDeviceName).WillRepeatedly(Return(SOFTBUS_OK));
400 EXPECT_CALL(mock, LnnConvertIdToDeviceType).WillRepeatedly(Return(nullptr));
401 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
402 EXPECT_EQ(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, INVALID_UNIFIED_NAME,
403 strlen(INVALID_UNIFIED_NAME)), EOK);
404 EXPECT_EQ(memcpy_s(info.uuid, UUID_BUF_LEN, INVALID_UDID, strlen(INVALID_UDID)), EOK);
405 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
406 int32_t ret = PackCommonDevInfo(json, &info, true);
407 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
408 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
409 ret = PackCommonDevInfo(json, &info, true);
410 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
411 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
412 EXPECT_EQ(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME, strlen(UNIFIED_NAME)), EOK);
413 EXPECT_EQ(memcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORK_ID_TEST, strlen(NETWORK_ID_TEST)), EOK);
414 EXPECT_EQ(
415 memcpy_s(info.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, DEVICE_NAME_TEST, strlen(DEVICE_NAME_TEST)), EOK);
416 info.deviceInfo.deviceTypeId = 12;
417 EXPECT_EQ(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)), EOK);
418 ret = PackCommonDevInfo(json, &info, false);
419 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
420 JSON_Delete(json);
421 }
422
423 /*
424 @tc.name: UnpackCipherRpaInfo_TEST_001
425 @tc.desc: Cipher Rpa information unpack test
426 @tc.type: FUNC
427 @tc.require:
428 */
429 HWTEST_F(AuthSessionJsonTest, UnpackCipherRpaInfo_TEST_001, TestSize.Level1)
430 {
431 JsonObj *json = JSON_CreateObject();
432 EXPECT_NE(json, nullptr);
433 AuthSessionJsonInterfaceMock mock;
434 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
435 EXPECT_CALL(mock, LnnGetUnifiedDeviceName).WillRepeatedly(Return(SOFTBUS_OK));
436 EXPECT_CALL(mock, LnnConvertIdToDeviceType).WillRepeatedly(Return(nullptr));
437 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, "cipherKeyTest");
438 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, "cipherIv");
439 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
440 (void)JSON_AddStringToObject(json, PUB_MAC, "pubMac");
441 NodeInfo info;
442 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
443 EXPECT_EQ(memcpy_s(info.cipherInfo.key, SESSION_KEY_LENGTH, KEY_TEST, strlen(KEY_TEST)), EOK);
444 EXPECT_EQ(memcpy_s(info.cipherInfo.iv, BROADCAST_IV_LEN, IV_TEST, strlen(IV_TEST)), EOK);
445 EXPECT_EQ(memcpy_s(info.rpaInfo.peerIrk, LFINDER_IRK_LEN, PEER_IRK, PEER_IRK_LEN), EOK);
446 EXPECT_EQ(memcpy_s(info.rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, PUBLIC_ADDRESS, PUBLIC_ADDRESS_LEN), EOK);
447 UnpackCipherRpaInfo(json, &info);
448 JSON_Delete(json);
449 JsonObj *json1 = JSON_CreateObject();
450 EXPECT_NE(json1, nullptr);
451 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
452 int32_t ret = PackCommon(json1, &info, SOFTBUS_OLD_V2, false);
453 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
454 ret = PackCommon(json1, &info, SOFTBUS_NEW_V1, false);
455 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
456 JSON_Delete(json1);
457 }
458
459 /*
460 @tc.name: UnpackWifiDirectInfo_TEST_001
461 @tc.desc: Wifi Direct information unpack interface test
462 @tc.type: FUNC
463 @tc.require:
464 */
465 HWTEST_F(AuthSessionJsonTest, UnpackWifiDirectInfo_TEST_001, TestSize.Level1)
466 {
467 JsonObj *json = JSON_CreateObject();
468 EXPECT_NE(json, nullptr);
469 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
470 NodeInfo info;
471 AuthSessionJsonInterfaceMock mock;
472 EXPECT_CALL(mock, LnnConvertDeviceTypeToId).WillRepeatedly(Return(SOFTBUS_OK));
473 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
474 EXPECT_CALL(mock, LnnGetAuthPort).WillRepeatedly(Return(SOFTBUS_OK));
475 EXPECT_CALL(mock, LnnGetSessionPort).WillRepeatedly(Return(SOFTBUS_OK));
476 EXPECT_CALL(mock, LnnGetProxyPort).WillRepeatedly(Return(SOFTBUS_OK));
477 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
478 EXPECT_CALL(mock, LnnGetUnifiedDeviceName).WillRepeatedly(Return(SOFTBUS_OK));
479 EXPECT_CALL(mock, LnnConvertIdToDeviceType).WillRepeatedly(Return(nullptr));
480 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
481 EXPECT_EQ(memcpy_s(info.staticCapability, STATIC_CAP_LEN, STATIC_CAPABILITY, CAPABILITY_LEN), EOK);
482 UnpackWifiDirectInfo(json, &info, false);
483 JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, 10);
484 UnpackWifiDirectInfo(json, &info, false);
485 JSON_AddStringToObject(json, STATIC_CAP, "staticCap");
486 UnpackWifiDirectInfo(json, &info, false);
487 JSON_AddStringToObject(json, PTK, "encodePtk");
488 UnpackWifiDirectInfo(json, &info, false);
489 EXPECT_EQ(memcpy_s(info.remotePtk, PTK_DEFAULT_LEN, REMOTE_PTK, strlen(REMOTE_PTK)), EOK);
490 UnpackWifiDirectInfo(json, &info, false);
491 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
492 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
493 JSON_AddStringToObject(json, DEVICE_UUID, "123456");
494 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
495 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
496 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
497 JSON_AddStringToObject(json, NODE_ADDR, "127.0.0.0");
498 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
499 char buf[10] = { 0 };
500 int32_t ret = GetBtDiscTypeString(nullptr, buf, 10);
501 EXPECT_EQ(ret, SOFTBUS_OK);
502 info.discoveryType = 11;
503 ret = GetBtDiscTypeString(&info, buf, 10);
504 EXPECT_EQ(ret, SOFTBUS_OK);
505 info.discoveryType = 15;
506 ret = UnpackBt(json, &info, SOFTBUS_NEW_V1, false);
507 EXPECT_EQ(ret, SOFTBUS_OK);
508 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 3);
509 ret = UnpackBt(json, &info, SOFTBUS_NEW_V1, false);
510 EXPECT_EQ(ret, SOFTBUS_OK);
511 ret = PackWiFi(json, &info, SOFTBUS_NEW_V1, false, WLAN_IF);
512 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
513 JSON_Delete(json);
514 }
515
516 /*
517 @tc.name: CheckBusVersion_TEST_001
518 @tc.desc: Check bus version information pack interface test
519 @tc.type: FUNC
520 @tc.require:
521 */
522 HWTEST_F(AuthSessionJsonTest, CheckBusVersion_TEST_001, TestSize.Level1)
523 {
524 JsonObj *json1 = JSON_CreateObject();
525 EXPECT_NE(json1, nullptr);
526 JSON_AddInt32ToObject(json1, BUS_MAX_VERSION, -1);
527 JSON_AddInt32ToObject(json1, BUS_MIN_VERSION, -1);
528 EXPECT_NE(CheckBusVersion(json1), SOFTBUS_OK);
529 NodeInfo info;
530 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
531 EXPECT_NE(UnpackWiFi(json1, &info, SOFTBUS_OLD_V1, false, WLAN_IF), SOFTBUS_OK);
532 JSON_Delete(json1);
533 JsonObj *json = JSON_CreateObject();
534 EXPECT_NE(json, nullptr);
535 JSON_AddInt32ToObject(json, BUS_MAX_VERSION, 3);
536 JSON_AddInt32ToObject(json, BUS_MIN_VERSION, 0);
537 EXPECT_TRUE(CheckBusVersion(json) == 2);
538 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false, WLAN_IF) == SOFTBUS_OK);
539 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 63);
540 JSON_AddStringToObject(json, BLE_OFFLINE_CODE, "123");
541 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false, WLAN_IF) == SOFTBUS_OK);
542 JSON_Delete(json);
543 }
544
545 /*
546 @tc.name: PackDeviceInfoBtV1_TEST_001
547 @tc.desc: Device BtV1 information pack interface test
548 @tc.type: FUNC
549 @tc.require:
550 */
551 HWTEST_F(AuthSessionJsonTest, PackDeviceInfoBtV1_TEST_001, TestSize.Level1)
552 {
553 NodeInfo info;
554 AuthSessionJsonInterfaceMock mock;
555 EXPECT_CALL(mock, LnnGetBtMac).WillOnce(Return(nullptr));
556 EXPECT_CALL(mock, LnnGetP2pMac).WillOnce(Return(nullptr));
557 int32_t ret = PackDeviceInfoBtV1(nullptr, &info, false);
558 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
559 JsonObj *json = JSON_CreateObject();
560 EXPECT_NE(json, nullptr);
561 EXPECT_CALL(mock, LnnGetBtMac).WillRepeatedly(Return("11:22:33:44:55"));
562 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
563 ret = PackDeviceInfoBtV1(json, &info, false);
564 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
565 ret = UnpackDeviceInfoBtV1(json, &info);
566 EXPECT_EQ(ret, SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL);
567 JSON_AddStringToObject(json, DEVICE_NAME, "testname");
568 ret = UnpackDeviceInfoBtV1(json, &info);
569 EXPECT_EQ(ret, SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL);
570 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
571 ret = UnpackDeviceInfoBtV1(json, &info);
572 EXPECT_EQ(ret, SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL);
573 JSON_AddStringToObject(json, DEVICE_UDID, "123456");
574 JSON_AddStringToObject(json, UUID, "123456");
575 JSON_AddStringToObject(json, BR_MAC_ADDR, "11:22:33:44:55");
576 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
577 ret = UnpackDeviceInfoBtV1(json, &info);
578 EXPECT_EQ(ret, SOFTBUS_OK);
579 JSON_Delete(json);
580 }
581
582 /*
583 @tc.name: UnpackDeviceInfoMessage_TEST_001
584 @tc.desc: Device message information unpack interface test
585 @tc.type: FUNC
586 @tc.require:
587 */
588 HWTEST_F(AuthSessionJsonTest, UnpackDeviceInfoMessage_TEST_001, TestSize.Level1)
589 {
590 DevInfoData devInfo;
591 NodeInfo nodeInfo;
592 AuthSessionInfo info;
593 AuthSessionJsonInterfaceMock mock;
594 EXPECT_CALL(mock, IsSupportUDIDAbatement).WillRepeatedly(Return(true));
595 EXPECT_CALL(mock, IsNeedUDIDAbatement).WillRepeatedly(Return(false));
596 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
597 EXPECT_CALL(mock, IsFeatureSupport).WillRepeatedly(Return(false));
598 (void)memset_s(&devInfo, sizeof(DevInfoData), 0, sizeof(DevInfoData));
599 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
600 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
601 JsonObj *obj = JSON_CreateObject();
602 EXPECT_NE(obj, nullptr);
603 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
604 char *msg = JSON_PrintUnformatted(obj);
605 devInfo.msg = msg;
606 devInfo.len = strlen(msg);
607 devInfo.linkType = AUTH_LINK_TYPE_BLE;
608 EXPECT_TRUE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info) == SOFTBUS_OK);
609 devInfo.linkType = AUTH_LINK_TYPE_WIFI;
610 nodeInfo.feature = 511;
611 EXPECT_NE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info), SOFTBUS_OK);
612 JSON_Delete(obj);
613 }
614
615 /*
616 @tc.name: PACK_FAST_AUTH_VALUE_TEST_001
617 @tc.desc: Pack fast auth value test
618 @tc.type: FUNC
619 @tc.require:
620 */
621 HWTEST_F(AuthSessionJsonTest, PACK_FAST_AUTH_VALUE_TEST_001, TestSize.Level1)
622 {
623 AuthDeviceKeyInfo deviceCommKey = { 0 };
624 JsonObj *obj = JSON_CreateObject();
625 ASSERT_NE(obj, nullptr);
626 uint32_t keyLen = 0;
627 deviceCommKey.keyLen = keyLen;
628 AuthSessionJsonInterfaceMock mock;
629 EXPECT_CALL(mock, LnnEncryptAesGcm).WillRepeatedly(Return(SOFTBUS_OK));
630 uint64_t ret = PackFastAuthValue(obj, &deviceCommKey);
631 EXPECT_NE(ret, SOFTBUS_OK);
632 JSON_Delete(obj);
633 }
634 /*
635 @tc.name: CHECK_BUS_VERSION_TEST_001
636 @tc.desc: check bus version test
637 @tc.type: FUNC
638 @tc.require:
639 */
640 HWTEST_F(AuthSessionJsonTest, CHECK_BUS_VERSION_TEST_001, TestSize.Level1)
641 {
642 JsonObj *obj = JSON_CreateObject();
643 if (obj == NULL) {
644 return;
645 }
646
647 NodeInfo *info = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
648 if (info == NULL) {
649 JSON_Delete(obj);
650 return;
651 }
652 (void)memset_s(info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
653
654 SoftBusVersion version = SOFTBUS_NEW_V1;
655 if (!JSON_AddInt32ToObject(obj, "CODE", (int32_t)1) ||
656 !JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)2) ||
657 !JSON_AddInt32ToObject(obj, "BUS_MIN_VERSION", (int32_t)1) ||
658 !JSON_AddInt32ToObject(obj, "AUTH_PORT", (int32_t)8710) ||
659 !JSON_AddInt32ToObject(obj, "SESSION_PORT", (int32_t)26) ||
660 !JSON_AddInt32ToObject(obj, "PROXY_PORT", (int32_t)80) ||
661 !JSON_AddStringToObject(obj, "DEV_IP", "127.0.0.1")) {
662 JSON_Delete(obj);
663 return;
664 }
665 JSON_AddStringToObject(obj, BLE_OFFLINE_CODE, "10244");
666
667 info->connectInfo.ifInfo[WLAN_IF].authPort = 8710;
668 info->connectInfo.ifInfo[WLAN_IF].sessionPort = 26;
669 info->connectInfo.ifInfo[WLAN_IF].proxyPort = 80;
670 info->supportedProtocols = LNN_PROTOCOL_BR;
671 int32_t ret = UnpackWiFi(obj, info, version, false, WLAN_IF);
672 EXPECT_EQ(ret, SOFTBUS_OK);
673 JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)-1);
674 ret = UnpackWiFi(obj, info, version, false, WLAN_IF);
675 EXPECT_NE(ret, SOFTBUS_OK);
676
677 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_KEY", "1222222222");
678 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_IV", "1222222222");
679 (void)JSON_AddStringToObject(obj, "IRK", "1222222222");
680 (void)JSON_AddStringToObject(obj, "PUB_MAC", "1222222222");
681
682 JSON_AddStringToObject(obj, "MASTER_UDID", "1122334554444");
683 JSON_AddStringToObject(obj, "NODE_ADDR", "1122334554444");
684 UnpackCommon(obj, info, version, false);
685 version = SOFTBUS_OLD_V1;
686 JSON_AddInt32ToObject(obj, "MASTER_WEIGHT", (int32_t)10);
687 UnpackCommon(obj, info, version, true);
688 UnpackCipherRpaInfo(obj, info);
689 JSON_Delete(obj);
690 SoftBusFree(info);
691 }
692
693 /*
694 @tc.name: PACK_FAST_AUTH_VALUE_TEST_002
695 @tc.desc: Fast auth value pack test
696 @tc.type: FUNC
697 @tc.require:
698 */
699 HWTEST_F(AuthSessionJsonTest, PACK_FAST_AUTH_VALUE_TEST_002, TestSize.Level1)
700 {
701 JsonObj *obj = JSON_CreateObject();
702 EXPECT_NE(obj, nullptr);
703 AuthDeviceKeyInfo deviceCommKey;
704 AuthSessionJsonInterfaceMock mock;
705 EXPECT_CALL(mock, LnnEncryptAesGcm).WillRepeatedly(Return(SOFTBUS_OK));
706 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
707 int32_t ret = SoftBusGenerateRandomArray(deviceCommKey.deviceKey, SESSION_KEY_LENGTH);
708 EXPECT_EQ(ret, SOFTBUS_OK);
709 deviceCommKey.keyLen = SESSION_KEY_LENGTH;
710 deviceCommKey.keyIndex = 12345;
711 ret = PackFastAuthValue(obj, &deviceCommKey);
712 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
713 JSON_Delete(obj);
714 }
715
716 /*
717 @tc.name: PACK_NORMALIZED_KEY_VALUE_TEST_001
718 @tc.desc: NormalizedKey Value pack interface test
719 @tc.type: FUNC
720 @tc.require:
721 */
722 HWTEST_F(AuthSessionJsonTest, PACK_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
723 {
724 int64_t authSeq = 1;
725 SessionKey sessionKey = {
726 .len = SESSION_KEY_LENGTH,
727 };
728 AuthSessionJsonInterfaceMock mock;
729 EXPECT_CALL(mock, LnnGetUdidByBrMac).WillRepeatedly(Return(SOFTBUS_OK));
730 EXPECT_CALL(mock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
731 EXPECT_CALL(mock, LnnEncryptAesGcm).WillRepeatedly(Return(SOFTBUS_OK));
732 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
733 JsonObj *obj = JSON_CreateObject();
734 EXPECT_NE(obj, nullptr);
735 AuthSessionInfo info = {
736 .isNeedFastAuth = false,
737 .isServer = false,
738 .normalizedType = NORMALIZED_KEY_ERROR,
739 .localState = AUTH_STATE_WAIT,
740 .connInfo.type = AUTH_LINK_TYPE_WIFI,
741 .normalizedKey = nullptr,
742 };
743 PackNormalizedKey(obj, &info, authSeq);
744 info.isNeedFastAuth = true;
745 PackNormalizedKey(obj, &info, authSeq);
746 info.isServer = true;
747 PackNormalizedKey(obj, &info, authSeq);
748 info.normalizedType = NORMALIZED_NOT_SUPPORT;
749 info.localState = AUTH_STATE_START;
750 PackNormalizedKey(obj, &info, authSeq);
751 info.normalizedKey = &sessionKey;
752 PackNormalizedKey(obj, &info, authSeq);
753 EXPECT_EQ(memcpy_s(info.connInfo.info.ipInfo.deviceIdHash, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)), EOK);
754 PackNormalizedKey(obj, &info, authSeq);
755 EXPECT_EQ(SOFTBUS_INVALID_PARAM, PackNormalizedKeyValue(obj, &sessionKey));
756 JSON_Delete(obj);
757 }
758
759 /*
760 @tc.name: PARSE_NORMALIZED_KEY_VALUE_TEST_001
761 @tc.desc: Parse NormalizedKey Value test
762 @tc.type: FUNC
763 @tc.require:
764 */
765 HWTEST_F(AuthSessionJsonTest, PARSE_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
766 {
767 int64_t authSeq = 1;
768 const char *encNormalizedKey = "encnormalizedkeytest";
769 SessionKey sessionKey = {
770 .len = SESSION_KEY_LENGTH,
771 };
772 AuthSessionJsonInterfaceMock mock;
773 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
774 EXPECT_CALL(mock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
775 EXPECT_CALL(mock, AuthFindNormalizeKeyByServerSide).WillRepeatedly(Return(SOFTBUS_OK));
776 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
777 AuthSessionInfo info;
778 EXPECT_NE(SOFTBUS_OK, ParseNormalizedKeyValue(&info, encNormalizedKey, &sessionKey));
779 ASSERT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
780 AuthDeviceKeyInfo deviceKey;
781 EXPECT_NE(SOFTBUS_OK, ParseNormalizeData(&info, const_cast<char *>(encNormalizedKey), &deviceKey, authSeq));
782 }
783
784 /*
785 @tc.name: PACK_DEVICE_JSON_INFO_TEST_001
786 @tc.desc: Device Json information pack test
787 @tc.type: FUNC
788 @tc.require:
789 */
790 HWTEST_F(AuthSessionJsonTest, PACK_DEVICE_JSON_INFO_TEST_001, TestSize.Level1)
791 {
792 int64_t authSeq = 1;
793 JsonObj *obj = JSON_CreateObject();
794 EXPECT_NE(obj, nullptr);
795 SessionKey sessionKey;
796 AuthSessionInfo info = {
797 .connInfo.type = AUTH_LINK_TYPE_WIFI,
798 .isConnectServer = false,
799 .localState = AUTH_STATE_START,
800 .isServer = false,
801 .normalizedKey = &sessionKey,
802 };
803 AuthSessionJsonInterfaceMock mock;
804 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
805 EXPECT_CALL(mock, AuthFindLatestNormalizeKey).WillRepeatedly(Return(SOFTBUS_OK));
806 EXPECT_CALL(mock, AuthFindNormalizeKeyByServerSide).WillRepeatedly(Return(SOFTBUS_OK));
807 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
808 const char *encNormalizedKey = "encnormalizedkeytest";
809 EXPECT_EQ(true, JSON_AddStringToObject(obj, NORMALIZED_DATA, encNormalizedKey));
810 UnpackNormalizedKey(obj, &info, NORMALIZED_NOT_SUPPORT, authSeq);
811 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT, authSeq);
812 info.isServer = true;
813 info.normalizedKey = nullptr;
814 EXPECT_EQ(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)), EOK);
815 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT, authSeq);
816 info.isConnectServer = true;
817 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
818 info.connInfo.type = AUTH_LINK_TYPE_BLE;
819 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
820 JSON_Delete(obj);
821 }
822
823 /*
824 @tc.name: PACK_DEVICE_INFO_MESSAGE_TEST_001
825 @tc.desc: Device Message information pack test
826 @tc.type: FUNC
827 @tc.require:
828 */
829 HWTEST_F(AuthSessionJsonTest, PACK_CERTIFICATE_INFO_TEST_001, TestSize.Level1)
830 {
831 JsonObj *obj = JSON_CreateObject();
832 EXPECT_NE(obj, nullptr);
833 NodeInfo info;
834 const char *staticCap = "staticCapTest";
835 const char *encodePtk = "encodePtkTest";
836 EXPECT_EQ(true, JSON_AddInt32ToObject(obj, STATIC_CAP_LENGTH, DATA_TEST_LEN));
837 EXPECT_EQ(true, JSON_AddStringToObject(obj, STATIC_CAP, staticCap));
838 EXPECT_EQ(true, JSON_AddStringToObject(obj, PTK, encodePtk));
839 UnpackWifiDirectInfo(obj, &info, false);
840 EXPECT_EQ(nullptr, PackDeviceInfoMessage(nullptr, SOFTBUS_NEW_V1, false, nullptr, nullptr));
841 JSON_Delete(obj);
842 }
843
844 /*
845 @tc.name: GenerateUdidShortHash_TEST_001
846 @tc.desc: Generate Udid Short Hash interface test
847 @tc.type: FUNC
848 @tc.require:
849 */
850 HWTEST_F(AuthSessionJsonTest, GenerateUdidShortHash_TEST_001, TestSize.Level1)
851 {
852 const char *udid = "123456";
853 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
854 AuthSessionJsonInterfaceMock mock;
855 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
856 EXPECT_TRUE(GenerateUdidShortHash(udid, udidHashHexStr, SHA_256_HEX_HASH_LEN));
857 EXPECT_TRUE(!GenerateUdidShortHash(udid, udidHashHexStr, 10));
858 }
859 }
860