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_session_json.c"
22 #include "auth_session_message.c"
23 #include "auth_session_message.h"
24 #include "softbus_adapter_crypto.h"
25 #include "softbus_adapter_json.h"
26 #include "softbus_error_code.h"
27
28 namespace OHOS {
29 using namespace testing::ext;
30 constexpr int32_t PEER_IRK_LEN = 13;
31 constexpr int32_t PUBLIC_ADDRESS_LEN = 4;
32 constexpr int32_t DATA_TEST_LEN = 7;
33 constexpr int32_t CAPABILITY_LEN = 16;
34 constexpr char DEVICE_KEY[SESSION_KEY_LENGTH] = "11111";
35 constexpr char UDID[UDID_BUF_LEN] = "123456789udidtest";
36 constexpr char UUID_TEST[UUID_BUF_LEN] = "123456789uuidtest";
37 constexpr char INVALID_UDID[UDID_BUF_LEN] = "\0";
38 constexpr char NETWORK_ID_TEST[NETWORK_ID_BUF_LEN] = "987654321";
39 constexpr uint8_t DATA_TEST[UDID_BUF_LEN] = "1111111";
40 constexpr char UNIFIED_NAME[DEVICE_NAME_BUF_LEN] = "unifiedName";
41 constexpr char INVALID_UNIFIED_NAME[DEVICE_NAME_BUF_LEN] = "\0";
42 constexpr char DEVICE_NAME_TEST[DEVICE_NAME_BUF_LEN] = "deviceName";
43 constexpr char KEY_TEST[SESSION_KEY_LENGTH] = "123456keytest";
44 constexpr char IV_TEST[BROADCAST_IV_LEN] = "123456ivtest";
45 constexpr uint8_t PEER_IRK[LFINDER_IRK_LEN] = "123456irktest";
46 constexpr unsigned char PUBLIC_ADDRESS[LFINDER_MAC_ADDR_LEN] = "addr";
47 constexpr uint8_t STATIC_CAPABILITY[STATIC_CAP_LEN] = "staticCapability";
48 constexpr char REMOTE_PTK[PTK_DEFAULT_LEN] = "remotePtktest";
49 constexpr int32_t TEST_DATA_LEN = 10;
50
51 class AuthSessionMessageTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void AuthSessionMessageTest::SetUpTestCase()
60 {
61 int32_t ret = AuthCommonInit();
62 EXPECT_TRUE(ret == SOFTBUS_OK);
63 }
64
TearDownTestCase()65 void AuthSessionMessageTest::TearDownTestCase()
66 {
67 AuthCommonDeinit();
68 }
69
SetUp()70 void AuthSessionMessageTest::SetUp() { }
71
TearDown()72 void AuthSessionMessageTest::TearDown() { }
73
74 /*
75 * @tc.name: PackFastAuthValue_TEST_001
76 * @tc.desc: PackFastAuthValue test
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(AuthSessionMessageTest, PackFastAuthValue_TEST_001, TestSize.Level1)
81 {
82 JsonObj *json = JSON_CreateObject();
83 EXPECT_TRUE(json != nullptr);
84 char target[10] = { 0 };
85 JSON_AddStringToObject(json, FAST_AUTH, "jsontest");
86 OptString(json, DEVICE_ID, target, 10, "");
87 OptString(json, FAST_AUTH, target, 10, "");
88 int32_t val = 0;
89 OptInt(json, P2P_ROLE, &val, 0);
90 JSON_AddInt32ToObject(json, SOFTBUS_VERSION_TAG, 123);
91 OptInt(json, SOFTBUS_VERSION_TAG, &val, 0);
92 int64_t value = 0;
93 OptInt64(json, NEW_CONN_CAP, &value, 1);
94 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
95 OptInt64(json, NEW_CONN_CAP, &value, 1);
96 bool result;
97 OptBool(json, BLE_P2P, &result, false);
98 JSON_AddBoolToObject(json, BLE_P2P, true);
99 OptBool(json, BLE_P2P, &result, false);
100 JSON_Delete(json);
101 JsonObj *obj = JSON_CreateObject();
102 EXPECT_TRUE(obj != nullptr);
103 AuthDeviceKeyInfo deviceCommKey;
104 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
105 EXPECT_TRUE(memcpy_s(deviceCommKey.deviceKey, SESSION_KEY_LENGTH, DEVICE_KEY, strlen(DEVICE_KEY)) == EOK);
106 deviceCommKey.keyLen = 5;
107 deviceCommKey.keyIndex = 12345;
108 EXPECT_NE(PackFastAuthValue(obj, &deviceCommKey), SOFTBUS_OK);
109 JSON_Delete(obj);
110 }
111
112 /*
113 * @tc.name: GenerateUdidShortHash_TEST_001
114 * @tc.desc: GenerateUdidShortHash test
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(AuthSessionMessageTest, GenerateUdidShortHash_TEST_001, TestSize.Level1)
119 {
120 const char *udid = "123456";
121 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
122 EXPECT_TRUE(GenerateUdidShortHash(udid, udidHashHexStr, SHA_256_HEX_HASH_LEN));
123 EXPECT_TRUE(!GenerateUdidShortHash(udid, udidHashHexStr, 10));
124 }
125
126 /*
127 * @tc.name: GetUdidOrShortHash_TEST_001
128 * @tc.desc: GetUdidOrShortHash test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(AuthSessionMessageTest, GetUdidOrShortHash_TEST_001, TestSize.Level1)
133 {
134 AuthSessionInfo info;
135 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
136 info.isServer = false;
137 info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
138 ASSERT_TRUE(memcpy_s(info.connInfo.info.ipInfo.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
139 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
140 EXPECT_TRUE(GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN));
141 info.isServer = true;
142 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
143 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
144 EXPECT_TRUE(GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN));
145 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
146 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, INVALID_UDID, strlen(INVALID_UDID)) == EOK);
147 EXPECT_TRUE(!GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN));
148 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
149 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
150 info.connInfo.type = AUTH_LINK_TYPE_BLE;
151 EXPECT_TRUE(GetUdidOrShortHash(&info, udidHashHexStr, SHA_256_HEX_HASH_LEN));
152 }
153
154 /*
155 * @tc.name: GetEnhancedP2pAuthKey_TEST_001
156 * @tc.desc: GetEnhancedP2pAuthKey test
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(AuthSessionMessageTest, GetEnhancedP2pAuthKey_TEST_001, TestSize.Level1)
161 {
162 AuthSessionInfo info;
163 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
164 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
165 EXPECT_NE(GetEnhancedP2pAuthKey(nullptr, &info, nullptr), SOFTBUS_OK);
166 info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
167 EXPECT_NE(GetFastAuthKey("hashtest", &info, nullptr), SOFTBUS_OK);
168 info.connInfo.type = AUTH_LINK_TYPE_BLE;
169 EXPECT_NE(GetFastAuthKey("hashtest", &info, nullptr), SOFTBUS_OK);
170 info.isServer = true;
171 info.isSupportFastAuth = true;
172 info.isNeedFastAuth = false;
173 PackFastAuth(nullptr, &info);
174 info.isNeedFastAuth = true;
175 PackFastAuth(nullptr, &info);
176 info.isSupportFastAuth = false;
177 PackFastAuth(nullptr, &info);
178 info.isServer = false;
179 info.isNeedFastAuth = true;
180 PackFastAuth(nullptr, &info);
181 }
182
183 /*
184 * @tc.name: VerifySessionInfoIdType_TEST_001
185 * @tc.desc: VerifySessionInfoIdType test
186 * @tc.type: FUNC
187 * @tc.require:
188 */
189 HWTEST_F(AuthSessionMessageTest, VerifySessionInfoIdType_TEST_001, TestSize.Level1)
190 {
191 AuthSessionInfo info;
192 const char *encryptedFastAuth = "encryptedFastAuth";
193 AuthDeviceKeyInfo deviceKey;
194 (void)memset_s(&deviceKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
195 ASSERT_TRUE(memcpy_s(deviceKey.deviceKey, SESSION_KEY_LENGTH, DEVICE_KEY, strlen(DEVICE_KEY)) == EOK);
196 deviceKey.keyLen = 5;
197 deviceKey.keyIndex = 12345;
198 ParseFastAuthValue(&info, encryptedFastAuth, &deviceKey);
199 JsonObj *obj = JSON_CreateObject();
200 EXPECT_TRUE(obj != nullptr);
201 JSON_AddStringToObject(obj, FAST_AUTH, encryptedFastAuth);
202 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
203 EXPECT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
204 info.connInfo.type = AUTH_LINK_TYPE_BLE;
205 UnpackFastAuth(obj, &info);
206 info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
207 UnpackFastAuth(obj, &info);
208 NodeInfo nodeInfo;
209 nodeInfo.feature = 127;
210 PackCompressInfo(obj, &nodeInfo);
211 nodeInfo.feature = 0;
212 PackCompressInfo(obj, &nodeInfo);
213 PackWifiSinglePassInfo(obj, &info);
214 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
215 PackWifiSinglePassInfo(obj, &info);
216 info.idType = EXCHANGE_NETWORKID;
217 EXPECT_TRUE(VerifySessionInfoIdType(&info, obj, const_cast<char *>(NETWORK_ID_TEST), const_cast<char *>(UDID)));
218 info.idType = EXCHANGE_UDID;
219 EXPECT_TRUE(VerifySessionInfoIdType(&info, obj, const_cast<char *>(NETWORK_ID_TEST), const_cast<char *>(UDID)));
220 JSON_Delete(obj);
221 }
222
223 /*
224 * @tc.name: PackDeviceIdJson_TEST_001
225 * @tc.desc: PackDeviceIdJson test
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(AuthSessionMessageTest, PackDeviceIdJson_TEST_001, TestSize.Level1)
230 {
231 AuthSessionInfo info;
232 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
233 int64_t authSeq = 1;
234 info.version = SOFTBUS_OLD_V1;
235 info.idType = EXCHANGE_UDID;
236 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
237 info.isServer = true;
238 EXPECT_TRUE(PackDeviceIdJson(&info, authSeq) == nullptr);
239 info.isServer = false;
240 EXPECT_TRUE(PackDeviceIdJson(&info, authSeq) == nullptr);
241 info.connInfo.type = AUTH_LINK_TYPE_BR;
242 EXPECT_TRUE(PackDeviceIdJson(&info, authSeq) == nullptr);
243 }
244
245 /*
246 * @tc.name: UnpackWifiSinglePassInfo_TEST_001
247 * @tc.desc: UnpackWifiSinglePassInfo test
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(AuthSessionMessageTest, UnpackWifiSinglePassInfo_TEST_001, TestSize.Level1)
252 {
253 AuthSessionInfo info;
254 info.connInfo.type = AUTH_LINK_TYPE_BR;
255 info.connId = 12;
256 JsonObj *obj = JSON_CreateObject();
257 EXPECT_TRUE(obj != nullptr);
258 JSON_AddStringToObject(obj, FAST_AUTH, "encryptedFastAuth");
259 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
260 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
261 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
262 JSON_AddStringToObject(obj, DEV_IP_HASH_TAG, "12345678");
263 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
264 JSON_Delete(obj);
265 }
266
267 /*
268 * @tc.name: UnPackBtDeviceIdV1_TEST_001
269 * @tc.desc: UnPackBtDeviceIdV1 test
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(AuthSessionMessageTest, UnPackBtDeviceIdV1_TEST_001, TestSize.Level1)
274 {
275 bool sessionSupportFlag = false;
276 SetCompressFlag("true", &sessionSupportFlag);
277 SetCompressFlag("false", &sessionSupportFlag);
278 AuthSessionInfo info;
279 info.isServer = false;
280 EXPECT_TRUE(UnPackBtDeviceIdV1(&info, DATA_TEST, DATA_TEST_LEN) == SOFTBUS_INVALID_PARAM);
281 info.isServer = true;
282 EXPECT_TRUE(UnPackBtDeviceIdV1(&info, DATA_TEST, DATA_TEST_LEN) == SOFTBUS_OK);
283 }
284
285 /*
286 * @tc.name: SetExchangeIdTypeAndValue_TEST_001
287 * @tc.desc: SetExchangeIdTypeAndValue test
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 HWTEST_F(AuthSessionMessageTest, SetExchangeIdTypeAndValue_TEST_001, TestSize.Level1)
292 {
293 JsonObj *obj1 = JSON_CreateObject();
294 EXPECT_TRUE(obj1 != nullptr);
295 AuthSessionInfo info;
296 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
297 info.idType = EXCHANGE_UDID;
298 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
299 EXPECT_TRUE(SetExchangeIdTypeAndValue(nullptr, &info) == SOFTBUS_INVALID_PARAM);
300 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, nullptr) == SOFTBUS_INVALID_PARAM);
301 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, &info) == SOFTBUS_OK);
302 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
303 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, &info) == SOFTBUS_OK);
304 JSON_Delete(obj1);
305 JsonObj *obj2 = JSON_CreateObject();
306 EXPECT_TRUE(obj2 != nullptr);
307 JSON_AddInt32ToObject(obj2, EXCHANGE_ID_TYPE, EXCHANGE_NETWORKID);
308 info.isServer = true;
309 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
310 info.isServer = false;
311 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
312 info.idType = EXCHANGE_NETWORKID;
313 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
314 JSON_Delete(obj2);
315 JsonObj *obj3 = JSON_CreateObject();
316 EXPECT_TRUE(obj3 != nullptr);
317 JSON_AddInt32ToObject(obj3, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
318 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj3, &info) == SOFTBUS_OK);
319 JSON_Delete(obj3);
320 }
321
322 /*
323 * @tc.name: UnpackDeviceIdJson_TEST_001
324 * @tc.desc: UnpackDeviceIdJson test
325 * @tc.type: FUNC
326 * @tc.require:
327 */
328 HWTEST_F(AuthSessionMessageTest, UnpackDeviceIdJson_TEST_001, TestSize.Level1)
329 {
330 int64_t authSeq = 1;
331 JsonObj *obj = JSON_CreateObject();
332 EXPECT_TRUE(obj != nullptr);
333 AuthSessionInfo info;
334 EXPECT_TRUE(UnpackDeviceIdJson(nullptr, 0, &info, authSeq) == SOFTBUS_INVALID_PARAM);
335 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
336 char *msg = JSON_PrintUnformatted(obj);
337 EXPECT_TRUE(UnpackDeviceIdJson(msg, strlen(msg), &info, authSeq) == SOFTBUS_NOT_FIND);
338 if (msg != nullptr) {
339 JSON_Free(msg);
340 }
341 JSON_Delete(obj);
342 JsonObj *obj1 = JSON_CreateObject();
343 EXPECT_TRUE(obj1 != nullptr);
344 JSON_AddStringToObject(obj1, CMD_TAG, CMD_GET_AUTH_INFO);
345 JSON_AddStringToObject(obj1, DATA_TAG, "123456");
346 JSON_AddStringToObject(obj1, DEVICE_ID_TAG, "654321");
347 JSON_AddInt32ToObject(obj1, DATA_BUF_SIZE_TAG, PACKET_SIZE);
348 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
349 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
350 JSON_AddStringToObject(obj1, SUPPORT_INFO_COMPRESS, TRUE_STRING_TAG);
351 char *msg1 = JSON_PrintUnformatted(obj1);
352 info.connInfo.type = AUTH_LINK_TYPE_BR;
353 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq) == SOFTBUS_CMP_FAIL);
354 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
355 info.isServer = false;
356 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq) == SOFTBUS_CMP_FAIL);
357 info.isConnectServer = true;
358 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info, authSeq) == SOFTBUS_OK);
359 if (msg1 != nullptr) {
360 JSON_Free(msg1);
361 }
362 JSON_Delete(obj1);
363 }
364
365 /*
366 * @tc.name: PackCommonDevInfo_TEST_001
367 * @tc.desc: PackCommonDevInfo test
368 * @tc.type: FUNC
369 * @tc.require:
370 */
371 HWTEST_F(AuthSessionMessageTest, PackCommonDevInfo_TEST_001, TestSize.Level1)
372 {
373 JsonObj *json = JSON_CreateObject();
374 EXPECT_TRUE(json != nullptr);
375 NodeInfo info;
376 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
377 EXPECT_TRUE(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, INVALID_UNIFIED_NAME,
378 strlen(INVALID_UNIFIED_NAME)) == EOK);
379 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, INVALID_UDID, strlen(INVALID_UDID)) == EOK);
380 EXPECT_TRUE(PackCommonDevInfo(json, &info, true) == SOFTBUS_OK);
381 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
382 EXPECT_TRUE(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME, strlen(UNIFIED_NAME)) == EOK);
383 EXPECT_TRUE(memcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORK_ID_TEST, strlen(NETWORK_ID_TEST)) == EOK);
384 EXPECT_TRUE(
385 memcpy_s(info.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, DEVICE_NAME_TEST, strlen(DEVICE_NAME_TEST)) == EOK);
386 info.deviceInfo.deviceTypeId = 12;
387 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
388 EXPECT_TRUE(PackCommonDevInfo(json, &info, false) == SOFTBUS_OK);
389 JSON_Delete(json);
390 }
391
392 /*
393 * @tc.name: UnpackCipherRpaInfo_TEST_001
394 * @tc.desc: UnpackCipherRpaInfo test
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(AuthSessionMessageTest, UnpackCipherRpaInfo_TEST_001, TestSize.Level1)
399 {
400 JsonObj *json = JSON_CreateObject();
401 EXPECT_TRUE(json != nullptr);
402 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, "cipherKeyTest");
403 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, "cipherIv");
404 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
405 (void)JSON_AddStringToObject(json, PUB_MAC, "pubMac");
406 NodeInfo info;
407 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
408 EXPECT_TRUE(memcpy_s(info.cipherInfo.key, SESSION_KEY_LENGTH, KEY_TEST, strlen(KEY_TEST)) == EOK);
409 EXPECT_TRUE(memcpy_s(info.cipherInfo.iv, BROADCAST_IV_LEN, IV_TEST, strlen(IV_TEST)) == EOK);
410 EXPECT_TRUE(memcpy_s(info.rpaInfo.peerIrk, LFINDER_IRK_LEN, PEER_IRK, PEER_IRK_LEN) == EOK);
411 EXPECT_TRUE(memcpy_s(info.rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, PUBLIC_ADDRESS, PUBLIC_ADDRESS_LEN) == EOK);
412 UnpackCipherRpaInfo(json, &info);
413 JSON_Delete(json);
414 JsonObj *json1 = JSON_CreateObject();
415 EXPECT_TRUE(json1 != nullptr);
416 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
417 EXPECT_TRUE(PackCommon(json1, &info, SOFTBUS_OLD_V2, false) == SOFTBUS_OK);
418 EXPECT_TRUE(PackCommon(json1, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
419 JSON_Delete(json1);
420 }
421
422 /*
423 * @tc.name: UnpackWifiDirectInfo_TEST_001
424 * @tc.desc: UnpackWifiDirectInfo test
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(AuthSessionMessageTest, UnpackWifiDirectInfo_TEST_001, TestSize.Level1)
429 {
430 JsonObj *json = JSON_CreateObject();
431 EXPECT_TRUE(json != nullptr);
432 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
433 NodeInfo info;
434 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
435 EXPECT_TRUE(memcpy_s(info.staticCapability, STATIC_CAP_LEN, STATIC_CAPABILITY, CAPABILITY_LEN) == EOK);
436 UnpackWifiDirectInfo(json, &info, false);
437 JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, 10);
438 UnpackWifiDirectInfo(json, &info, false);
439 JSON_AddStringToObject(json, STATIC_CAP, "staticCap");
440 UnpackWifiDirectInfo(json, &info, false);
441 JSON_AddStringToObject(json, PTK, "encodePtk");
442 UnpackWifiDirectInfo(json, &info, false);
443 EXPECT_TRUE(memcpy_s(info.remotePtk, PTK_DEFAULT_LEN, REMOTE_PTK, strlen(REMOTE_PTK)) == EOK);
444 UnpackWifiDirectInfo(json, &info, false);
445 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
446 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
447 JSON_AddStringToObject(json, DEVICE_UUID, "123456");
448 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
449 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
450 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
451 JSON_AddStringToObject(json, NODE_ADDR, "127.0.0.0");
452 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
453 char buf[10] = { 0 };
454 EXPECT_TRUE(GetBtDiscTypeString(nullptr, buf, 10) == SOFTBUS_OK);
455 info.discoveryType = 11;
456 EXPECT_TRUE(GetBtDiscTypeString(&info, buf, 10) == SOFTBUS_OK);
457 info.discoveryType = 15;
458 EXPECT_TRUE(UnpackBt(json, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
459 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 3);
460 EXPECT_TRUE(UnpackBt(json, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
461 EXPECT_TRUE(PackWiFi(json, &info, SOFTBUS_NEW_V1, false, WLAN_IF) == SOFTBUS_OK);
462 JSON_Delete(json);
463 }
464
465 /*
466 * @tc.name: CheckBusVersion_TEST_001
467 * @tc.desc: CheckBusVersion test
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(AuthSessionMessageTest, CheckBusVersion_TEST_001, TestSize.Level1)
472 {
473 JsonObj *json1 = JSON_CreateObject();
474 EXPECT_TRUE(json1 != nullptr);
475 JSON_AddInt32ToObject(json1, BUS_MAX_VERSION, -1);
476 JSON_AddInt32ToObject(json1, BUS_MIN_VERSION, -1);
477 EXPECT_NE(CheckBusVersion(json1), SOFTBUS_OK);
478 NodeInfo info;
479 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
480 EXPECT_NE(UnpackWiFi(json1, &info, SOFTBUS_OLD_V1, false, WLAN_IF), SOFTBUS_OK);
481 JSON_Delete(json1);
482 JsonObj *json = JSON_CreateObject();
483 EXPECT_TRUE(json != nullptr);
484 JSON_AddInt32ToObject(json, BUS_MAX_VERSION, 3);
485 JSON_AddInt32ToObject(json, BUS_MIN_VERSION, 0);
486 ;
487 EXPECT_TRUE(CheckBusVersion(json) == 2);
488 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false, WLAN_IF) == SOFTBUS_OK);
489 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 63);
490 JSON_AddStringToObject(json, BLE_OFFLINE_CODE, "123");
491 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false, WLAN_IF) == SOFTBUS_OK);
492 JSON_Delete(json);
493 }
494
495 /*
496 * @tc.name: PackDeviceInfoBtV1_TEST_001
497 * @tc.desc: PackDeviceInfoBtV1 test
498 * @tc.type: FUNC
499 * @tc.require:
500 */
501 HWTEST_F(AuthSessionMessageTest, PackDeviceInfoBtV1_TEST_001, TestSize.Level1)
502 {
503 NodeInfo info;
504 EXPECT_TRUE(PackDeviceInfoBtV1(nullptr, &info, false) == SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
505 JsonObj *json = JSON_CreateObject();
506 EXPECT_TRUE(json != nullptr);
507 EXPECT_TRUE(PackDeviceInfoBtV1(json, &info, false) == SOFTBUS_OK);
508 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
509 JSON_AddStringToObject(json, DEVICE_NAME, "testname");
510 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
511 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
512 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
513 JSON_AddStringToObject(json, DEVICE_UDID, "123456");
514 JSON_AddStringToObject(json, UUID, "123456");
515 JSON_AddStringToObject(json, BR_MAC_ADDR, "11:22:33:44:55");
516 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
517 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
518 JSON_Delete(json);
519 }
520
521 /*
522 * @tc.name: UpdatePeerDeviceName_TEST_001
523 * @tc.desc: UpdatePeerDeviceName test
524 * @tc.type: FUNC
525 * @tc.require:
526 */
527 HWTEST_F(AuthSessionMessageTest, UpdatePeerDeviceName_TEST_001, TestSize.Level1)
528 {
529 NodeInfo peerNodeInfo;
530 (void)memset_s(&peerNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
531 UpdatePeerDeviceName(&peerNodeInfo);
532 ASSERT_TRUE(
533 memcpy_s(peerNodeInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME, strlen(UNIFIED_NAME)) == EOK);
534 ASSERT_TRUE(memcpy_s(peerNodeInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, DEVICE_NAME_TEST,
535 strlen(DEVICE_NAME_TEST)) == EOK);
536 UpdatePeerDeviceName(&peerNodeInfo);
537 ASSERT_TRUE(memcpy_s(peerNodeInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME,
538 strlen(UNIFIED_NAME)) == EOK);
539 UpdatePeerDeviceName(&peerNodeInfo);
540 AuthSessionInfo info;
541 EXPECT_TRUE(PostDeviceIdData(123, &info, nullptr, 0) == SOFTBUS_AUTH_SEND_FAIL);
542 info.isServer = false;
543 EXPECT_NE(PostBtV1DevId(123, &info), SOFTBUS_OK);
544 EXPECT_NE(PostWifiV1DevId(123, &info), SOFTBUS_OK);
545 info.isServer = true;
546 EXPECT_NE(PostBtV1DevId(123, &info), SOFTBUS_OK);
547 EXPECT_NE(PostWifiV1DevId(123, &info), SOFTBUS_OK);
548 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
549 EXPECT_NE(PostDeviceIdV1(123, &info), SOFTBUS_OK);
550 info.connInfo.type = AUTH_LINK_TYPE_BLE;
551 EXPECT_NE(PostDeviceIdV1(123, &info), SOFTBUS_OK);
552 EXPECT_NE(PostDeviceIdNew(123, &info), SOFTBUS_OK);
553 EXPECT_TRUE(PostCloseAckMessage(123, &info) == SOFTBUS_AUTH_SEND_FAIL);
554 }
555
556 /*
557 * @tc.name: ProcessDeviceIdMessage_TEST_001
558 * @tc.desc: ProcessDeviceIdMessage test
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(AuthSessionMessageTest, ProcessDeviceIdMessage_TEST_001, TestSize.Level1)
563 {
564 AuthSessionInfo info;
565 int64_t authSeq = 1;
566 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
567 uint8_t data[] = "test";
568 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN, authSeq) == SOFTBUS_INVALID_PARAM);
569 info.connInfo.type = AUTH_LINK_TYPE_BLE;
570 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN + 1, authSeq) == SOFTBUS_INVALID_PARAM);
571 info.isServer = false;
572 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN, authSeq) == SOFTBUS_INVALID_PARAM);
573 info.isServer = true;
574 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN, authSeq) == SOFTBUS_OK);
575 }
576
577 /*
578 * @tc.name: UnpackDeviceInfoMessage_TEST_001
579 * @tc.desc: UnpackDeviceInfoMessage test
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(AuthSessionMessageTest, UnpackDeviceInfoMessage_TEST_001, TestSize.Level1)
584 {
585 DevInfoData devInfo;
586 NodeInfo nodeInfo;
587 AuthSessionInfo info;
588 (void)memset_s(&devInfo, sizeof(DevInfoData), 0, sizeof(DevInfoData));
589 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
590 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
591 JsonObj *obj = JSON_CreateObject();
592 EXPECT_TRUE(obj != nullptr);
593 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
594 char *msg = JSON_PrintUnformatted(obj);
595 devInfo.msg = msg;
596 devInfo.len = strlen(msg);
597 devInfo.linkType = AUTH_LINK_TYPE_BLE;
598 EXPECT_TRUE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info) == SOFTBUS_OK);
599 devInfo.linkType = AUTH_LINK_TYPE_WIFI;
600 nodeInfo.feature = 511;
601 EXPECT_NE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info), SOFTBUS_OK);
602 JSON_Delete(obj);
603 }
604
605 /*
606 * @tc.name: IsDeviceMessagePacket_TEST_001
607 * @tc.desc: IsDeviceMessagePacket test
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(AuthSessionMessageTest, IsDeviceMessagePacket_TEST_001, TestSize.Level1)
612 {
613 AuthConnInfo connInfo;
614 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
615 DeviceMessageParse messageParse = { 0 };
616 connInfo.type = AUTH_LINK_TYPE_BLE;
617 EXPECT_TRUE(!IsDeviceMessagePacket(&connInfo, nullptr, nullptr, true, &messageParse));
618 connInfo.type = AUTH_LINK_TYPE_WIFI;
619 EXPECT_TRUE(!IsDeviceMessagePacket(&connInfo, nullptr, nullptr, true, &messageParse));
620 }
621
622 /*
623 * @tc.name: PACK_FAST_AUTH_VALUE_TEST_001
624 * @tc.desc: Pack fast auth value test
625 * @tc.type: FUNC
626 * @tc.require:
627 */
628 HWTEST_F(AuthSessionMessageTest, PACK_FAST_AUTH_VALUE_TEST_001, TestSize.Level1)
629 {
630 AuthDeviceKeyInfo deviceCommKey = { 0 };
631 JsonObj *obj = JSON_CreateObject();
632 ASSERT_NE(obj, nullptr);
633 uint32_t keyLen = 0;
634 deviceCommKey.keyLen = keyLen;
635 uint64_t ret = PackFastAuthValue(obj, &deviceCommKey);
636 EXPECT_NE(ret, SOFTBUS_OK);
637 JSON_Delete(obj);
638 }
639
640 /*
641 * @tc.name: CHECK_BUS_VERSION_TEST_001
642 * @tc.desc: check bus version test
643 * @tc.type: FUNC
644 * @tc.require:
645 */
646 HWTEST_F(AuthSessionMessageTest, CHECK_BUS_VERSION_TEST_001, TestSize.Level1)
647 {
648 JsonObj *obj = JSON_CreateObject();
649 if (obj == nullptr) {
650 return;
651 }
652
653 NodeInfo *info = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
654 if (info == nullptr) {
655 JSON_Delete(obj);
656 return;
657 }
658 (void)memset_s(info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
659
660 SoftBusVersion version = SOFTBUS_NEW_V1;
661 if (!JSON_AddInt32ToObject(obj, "CODE", (int32_t)1) || !JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)2) ||
662 !JSON_AddInt32ToObject(obj, "BUS_MIN_VERSION", (int32_t)1) ||
663 !JSON_AddInt32ToObject(obj, "AUTH_PORT", (int32_t)8710) ||
664 !JSON_AddInt32ToObject(obj, "SESSION_PORT", (int32_t)26) ||
665 !JSON_AddInt32ToObject(obj, "PROXY_PORT", (int32_t)80) || !JSON_AddStringToObject(obj, "DEV_IP", "127.0.0.1")) {
666 JSON_Delete(obj);
667 return;
668 }
669 JSON_AddStringToObject(obj, BLE_OFFLINE_CODE, "10244");
670
671 info->connectInfo.ifInfo[WLAN_IF].authPort = 8710;
672 info->connectInfo.ifInfo[WLAN_IF].sessionPort = 26;
673 info->connectInfo.ifInfo[WLAN_IF].proxyPort = 80;
674 info->supportedProtocols = LNN_PROTOCOL_BR;
675
676 int32_t ret = UnpackWiFi(obj, info, version, false, WLAN_IF);
677 EXPECT_TRUE(ret == SOFTBUS_OK);
678 JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)-1);
679 ret = UnpackWiFi(obj, info, version, false, WLAN_IF);
680 EXPECT_NE(ret, SOFTBUS_OK);
681
682 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_KEY", "1222222222");
683 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_IV", "1222222222");
684 (void)JSON_AddStringToObject(obj, "IRK", "1222222222");
685 (void)JSON_AddStringToObject(obj, "PUB_MAC", "1222222222");
686
687 JSON_AddStringToObject(obj, "MASTER_UDID", "1122334554444");
688 JSON_AddStringToObject(obj, "NODE_ADDR", "1122334554444");
689 UnpackCommon(obj, info, version, false);
690 version = SOFTBUS_OLD_V1;
691 JSON_AddInt32ToObject(obj, "MASTER_WEIGHT", (int32_t)10);
692 UnpackCommon(obj, info, version, true);
693 UnpackCipherRpaInfo(obj, info);
694 JSON_Delete(obj);
695 SoftBusFree(info);
696 }
697
698 /*
699 * @tc.name: POST_BT_V1_DEVID_TEST_001
700 * @tc.desc: post bt v1 devid test
701 * @tc.type: FUNC
702 * @tc.require:
703 */
704 HWTEST_F(AuthSessionMessageTest, POST_BT_V1_DEVID_TEST_001, TestSize.Level1)
705 {
706 int64_t authSeq = 0;
707 AuthSessionInfo *info = (AuthSessionInfo *)SoftBusCalloc(sizeof(AuthSessionInfo));
708 if (info == nullptr) {
709 return;
710 }
711 info->requestId = 1;
712 info->connId = 1;
713 info->isServer = false;
714 info->version = SOFTBUS_NEW_V1;
715 info->connInfo.type = AUTH_LINK_TYPE_WIFI;
716 int32_t ret = PostDeviceIdV1(authSeq, info);
717 EXPECT_NE(ret, SOFTBUS_OK);
718 SoftBusFree(info);
719 }
720
721 /*
722 * @tc.name: IS_EMPTY_SHORT_HASH_STR_TEST_001
723 * @tc.desc:
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(AuthSessionMessageTest, IS_EMPTY_SHORT_HASH_STR_TEST_001, TestSize.Level1)
728 {
729 char udidHash[SHA_256_HEX_HASH_LEN];
730 const char *udidHash1 = "123456";
731 const char *udidHash2 = "0000000000000000000000000000000000000000000000000000000000000000";
732 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
733 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), "") == EOK);
734 bool ret = IsEmptyShortHashStr(udidHash);
735 EXPECT_EQ(ret, true);
736
737 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
738 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), udidHash1) == EOK);
739 ret = IsEmptyShortHashStr(udidHash);
740 EXPECT_EQ(ret, false);
741
742 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
743 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), udidHash2) == EOK);
744 ret = IsEmptyShortHashStr(udidHash);
745 EXPECT_EQ(ret, true);
746 }
747
748 /*
749 * @tc.name: GET_LOCAL_UDISHASH_TEST_001
750 * @tc.desc:
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(AuthSessionMessageTest, GET_LOCAL_UDISHASH_TEST_001, TestSize.Level1)
755 {
756 int32_t ret = GetLocalUdidHash(nullptr, nullptr, 0);
757 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
758 }
759
760 /*
761 * @tc.name: UPDATE_LOCAL_AUTH_STATE_TEST_001
762 * @tc.desc:
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(AuthSessionMessageTest, UPDATE_LOCAL_AUTH_STATE_TEST_001, TestSize.Level1)
767 {
768 uint64_t authSeq = 512;
769 AuthSessionInfo info;
770 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
771 info.isServer = true;
772 int32_t ret = UpdateLocalAuthState(authSeq, &info);
773 EXPECT_EQ(ret, SOFTBUS_OK);
774
775 info.isServer = false;
776 info.peerState = AUTH_STATE_COMPATIBLE;
777 ret = UpdateLocalAuthState(authSeq, &info);
778 EXPECT_EQ(ret, SOFTBUS_OK);
779
780 info.peerState = AUTH_STATE_ACK;
781 ret = UpdateLocalAuthState(authSeq, &info);
782 EXPECT_EQ(ret, SOFTBUS_OK);
783 }
784
785 /*
786 * @tc.name: PACK_FAST_AUTH_VALUE_TEST_002
787 * @tc.desc: PackFastAuthValue test
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(AuthSessionMessageTest, PACK_FAST_AUTH_VALUE_TEST_002, TestSize.Level1)
792 {
793 JsonObj *obj = JSON_CreateObject();
794 EXPECT_TRUE(obj != nullptr);
795 AuthDeviceKeyInfo deviceCommKey;
796 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
797 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(deviceCommKey.deviceKey, SESSION_KEY_LENGTH));
798 deviceCommKey.keyLen = SESSION_KEY_LENGTH;
799 deviceCommKey.keyIndex = 12345;
800 EXPECT_TRUE(PackFastAuthValue(obj, &deviceCommKey) == SOFTBUS_OK);
801 JSON_Delete(obj);
802 }
803
804 /*
805 * @tc.name: GET_UDID_SHORT_HASH_TEST_001
806 * @tc.desc: GetUdidShortHash test
807 * @tc.type: FUNC
808 * @tc.require:
809 */
810 HWTEST_F(AuthSessionMessageTest, GET_UDID_SHORT_HASH_TEST_001, TestSize.Level1)
811 {
812 AuthSessionInfo info = {
813 .connInfo.type = AUTH_LINK_TYPE_BR,
814 .isServer = true,
815 };
816 uint32_t bufLen = UDID_SHORT_HASH_HEX_STR;
817 char udidHash[SHORT_UDID_HASH_HEX_LEN + 1];
818 EXPECT_EQ(false, GetUdidShortHash(nullptr, nullptr, bufLen));
819 EXPECT_EQ(false, GetUdidShortHash(&info, nullptr, bufLen));
820 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
821 bufLen++;
822 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
823 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
824 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
825 info.connInfo.type = AUTH_LINK_TYPE_BLE;
826 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
827 info.connInfo.type = AUTH_LINK_TYPE_P2P;
828 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
829 info.isServer = false;
830 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
831 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
832 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
833 }
834
835 /*
836 * @tc.name: PACK_NORMALIZED_KEY_VALUE_TEST_001
837 * @tc.desc: PackNormalizedKeyValue test
838 * @tc.type: FUNC
839 * @tc.require:
840 */
841 HWTEST_F(AuthSessionMessageTest, PACK_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
842 {
843 SessionKey sessionKey = {
844 .len = SESSION_KEY_LENGTH,
845 };
846 int64_t authSeq = 1;
847 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
848 JsonObj *obj = JSON_CreateObject();
849 EXPECT_TRUE(obj != nullptr);
850 AuthSessionInfo info = {
851 .isNeedFastAuth = false,
852 .isServer = false,
853 .normalizedType = NORMALIZED_KEY_ERROR,
854 .localState = AUTH_STATE_WAIT,
855 .connInfo.type = AUTH_LINK_TYPE_WIFI,
856 .normalizedKey = nullptr,
857 };
858 PackNormalizedKey(obj, &info, authSeq);
859 info.isNeedFastAuth = true;
860 PackNormalizedKey(obj, &info, authSeq);
861 info.isServer = true;
862 PackNormalizedKey(obj, &info, authSeq);
863 info.normalizedType = NORMALIZED_NOT_SUPPORT;
864 info.localState = AUTH_STATE_START;
865 PackNormalizedKey(obj, &info, authSeq);
866 info.normalizedKey = &sessionKey;
867 PackNormalizedKey(obj, &info, authSeq);
868 EXPECT_TRUE(memcpy_s(info.connInfo.info.ipInfo.deviceIdHash, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
869 PackNormalizedKey(obj, &info, authSeq);
870 EXPECT_EQ(SOFTBUS_OK, PackNormalizedKeyValue(obj, &sessionKey));
871 JSON_Delete(obj);
872 }
873
874 /*
875 * @tc.name: PARSE_NORMALIZED_KEY_VALUE_TEST_001
876 * @tc.desc: ParseNormalizedKeyValue test
877 * @tc.type: FUNC
878 * @tc.require:
879 */
880 HWTEST_F(AuthSessionMessageTest, PARSE_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
881 {
882 int64_t authSeq = 1;
883 const char *encNormalizedKey = "encnormalizedkeytest";
884 SessionKey sessionKey = {
885 .len = SESSION_KEY_LENGTH,
886 };
887 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
888 AuthSessionInfo info;
889 EXPECT_NE(SOFTBUS_OK, ParseNormalizedKeyValue(&info, encNormalizedKey, &sessionKey));
890 ASSERT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
891 AuthDeviceKeyInfo deviceKey;
892 EXPECT_NE(SOFTBUS_OK, ParseNormalizeData(&info, const_cast<char *>(encNormalizedKey), &deviceKey, authSeq));
893 }
894
895 /*
896 * @tc.name: PACK_DEVICE_JSON_INFO_TEST_001
897 * @tc.desc: PackDeviceJsonInfo test
898 * @tc.type: FUNC
899 * @tc.require:
900 */
901 HWTEST_F(AuthSessionMessageTest, PACK_DEVICE_JSON_INFO_TEST_001, TestSize.Level1)
902 {
903 int64_t authSeq = 1;
904 JsonObj *obj = JSON_CreateObject();
905 EXPECT_TRUE(obj != nullptr);
906 SessionKey sessionKey;
907 AuthSessionInfo info = {
908 .connInfo.type = AUTH_LINK_TYPE_WIFI,
909 .isConnectServer = false,
910 .localState = AUTH_STATE_START,
911 .isServer = false,
912 .normalizedKey = &sessionKey,
913 };
914 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
915 const char *encNormalizedKey = "encnormalizedkeytest";
916 EXPECT_EQ(true, JSON_AddStringToObject(obj, NORMALIZED_DATA, encNormalizedKey));
917 UnpackNormalizedKey(obj, &info, NORMALIZED_NOT_SUPPORT, authSeq);
918 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT, authSeq);
919 info.isServer = true;
920 info.normalizedKey = nullptr;
921 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
922 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT, authSeq);
923 info.isConnectServer = true;
924 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
925 info.connInfo.type = AUTH_LINK_TYPE_BLE;
926 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
927 JSON_Delete(obj);
928 }
929
930 /*
931 * @tc.name: PACK_DEVICE_INFO_MESSAGE_TEST_001
932 * @tc.desc: PackDeviceInfoMessage test
933 * @tc.type: FUNC
934 * @tc.require:
935 */
936 HWTEST_F(AuthSessionMessageTest, PACK_CERTIFICATE_INFO_TEST_001, TestSize.Level1)
937 {
938 JsonObj *obj = JSON_CreateObject();
939 EXPECT_TRUE(obj != nullptr);
940 NodeInfo info;
941 const char *staticCap = "staticCapTest";
942 const char *encodePtk = "encodePtkTest";
943 EXPECT_EQ(true, JSON_AddInt32ToObject(obj, STATIC_CAP_LENGTH, DATA_TEST_LEN));
944 EXPECT_EQ(true, JSON_AddStringToObject(obj, STATIC_CAP, staticCap));
945 EXPECT_EQ(true, JSON_AddStringToObject(obj, PTK, encodePtk));
946 UnpackWifiDirectInfo(obj, &info, false);
947 EXPECT_EQ(nullptr, PackDeviceInfoMessage(nullptr, SOFTBUS_NEW_V1, false, nullptr, nullptr));
948 JSON_Delete(obj);
949 }
950
951 /*
952 * @tc.name: GET_DUMP_SESSIONKEY_LIST_TEST_001
953 * @tc.desc: GetDumpSessionKeyList test
954 * @tc.type: FUNC
955 * @tc.require:
956 */
957 HWTEST_F(AuthSessionMessageTest, GET_DUMP_SESSIONKEY_LIST_TEST_001, TestSize.Level1)
958 {
959 AuthSessionInfo info;
960 uint64_t connId = 1;
961 int64_t authSeq = 1;
962 SessionKeyList sessionKeyList;
963 info.connId = connId;
964 info.isServer = false;
965 info.isSupportFastAuth = true;
966 info.connInfo.type = AUTH_LINK_TYPE_BLE;
967 info.version = SOFTBUS_OLD_V1;
968 SessionKey sessionKey;
969 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
970 ASSERT_TRUE(memcpy_s(sessionKey.value, SESSION_KEY_LENGTH, KEY_TEST, PEER_IRK_LEN) == EOK);
971 sessionKey.len = PEER_IRK_LEN;
972 EXPECT_TRUE(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, false, false) == SOFTBUS_OK);
973 GetDumpSessionKeyList(authSeq, &info, &sessionKeyList);
974
975 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
976 info.isSupportCompress = true;
977 uint8_t compressData[TEST_DATA_LEN] = { 0 };
978 uint32_t compressLen = TEST_DATA_LEN;
979 char data[TEST_DATA_LEN] = { 0 };
980 InDataInfo inDataInfo;
981 (void)memset_s(&inDataInfo, sizeof(InDataInfo), 0, sizeof(InDataInfo));
982 SetIndataInfo(&inDataInfo, nullptr, 0, data);
983 SetIndataInfo(&inDataInfo, nullptr, compressLen, data);
984 SetIndataInfo(&inDataInfo, compressData, 0, data);
985 }
986 } // namespace OHOS
987