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 info.version = SOFTBUS_OLD_V1;
234 info.idType = EXCHANGE_UDID;
235 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
236 info.isServer = true;
237 EXPECT_TRUE(PackDeviceIdJson(&info) == nullptr);
238 info.isServer = false;
239 EXPECT_TRUE(PackDeviceIdJson(&info) == nullptr);
240 info.connInfo.type = AUTH_LINK_TYPE_BR;
241 EXPECT_TRUE(PackDeviceIdJson(&info) == nullptr);
242 }
243
244 /*
245 * @tc.name: UnpackWifiSinglePassInfo_TEST_001
246 * @tc.desc: UnpackWifiSinglePassInfo test
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(AuthSessionMessageTest, UnpackWifiSinglePassInfo_TEST_001, TestSize.Level1)
251 {
252 AuthSessionInfo info;
253 info.connInfo.type = AUTH_LINK_TYPE_BR;
254 info.connId = 12;
255 JsonObj *obj = JSON_CreateObject();
256 EXPECT_TRUE(obj != nullptr);
257 JSON_AddStringToObject(obj, FAST_AUTH, "encryptedFastAuth");
258 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
259 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
260 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
261 JSON_AddStringToObject(obj, DEV_IP_HASH_TAG, "12345678");
262 EXPECT_TRUE(UnpackWifiSinglePassInfo(obj, &info));
263 JSON_Delete(obj);
264 }
265
266 /*
267 * @tc.name: UnPackBtDeviceIdV1_TEST_001
268 * @tc.desc: UnPackBtDeviceIdV1 test
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(AuthSessionMessageTest, UnPackBtDeviceIdV1_TEST_001, TestSize.Level1)
273 {
274 bool sessionSupportFlag = false;
275 SetCompressFlag("true", &sessionSupportFlag);
276 SetCompressFlag("false", &sessionSupportFlag);
277 AuthSessionInfo info;
278 info.isServer = false;
279 EXPECT_TRUE(UnPackBtDeviceIdV1(&info, DATA_TEST, DATA_TEST_LEN) == SOFTBUS_INVALID_PARAM);
280 info.isServer = true;
281 EXPECT_TRUE(UnPackBtDeviceIdV1(&info, DATA_TEST, DATA_TEST_LEN) == SOFTBUS_OK);
282 }
283
284 /*
285 * @tc.name: SetExchangeIdTypeAndValue_TEST_001
286 * @tc.desc: SetExchangeIdTypeAndValue test
287 * @tc.type: FUNC
288 * @tc.require:
289 */
290 HWTEST_F(AuthSessionMessageTest, SetExchangeIdTypeAndValue_TEST_001, TestSize.Level1)
291 {
292 JsonObj *obj1 = JSON_CreateObject();
293 EXPECT_TRUE(obj1 != nullptr);
294 AuthSessionInfo info;
295 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
296 info.idType = EXCHANGE_UDID;
297 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
298 EXPECT_TRUE(SetExchangeIdTypeAndValue(nullptr, &info) == SOFTBUS_INVALID_PARAM);
299 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, nullptr) == SOFTBUS_INVALID_PARAM);
300 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, &info) == SOFTBUS_OK);
301 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
302 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj1, &info) == SOFTBUS_OK);
303 JSON_Delete(obj1);
304 JsonObj *obj2 = JSON_CreateObject();
305 EXPECT_TRUE(obj2 != nullptr);
306 JSON_AddInt32ToObject(obj2, EXCHANGE_ID_TYPE, EXCHANGE_NETWORKID);
307 info.isServer = true;
308 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
309 info.isServer = false;
310 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
311 info.idType = EXCHANGE_NETWORKID;
312 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj2, &info) == SOFTBUS_OK);
313 JSON_Delete(obj2);
314 JsonObj *obj3 = JSON_CreateObject();
315 EXPECT_TRUE(obj3 != nullptr);
316 JSON_AddInt32ToObject(obj3, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
317 EXPECT_TRUE(SetExchangeIdTypeAndValue(obj3, &info) == SOFTBUS_OK);
318 JSON_Delete(obj3);
319 }
320
321 /*
322 * @tc.name: UnpackDeviceIdJson_TEST_001
323 * @tc.desc: UnpackDeviceIdJson test
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(AuthSessionMessageTest, UnpackDeviceIdJson_TEST_001, TestSize.Level1)
328 {
329 JsonObj *obj = JSON_CreateObject();
330 EXPECT_TRUE(obj != nullptr);
331 AuthSessionInfo info;
332 EXPECT_TRUE(UnpackDeviceIdJson(nullptr, 0, &info) == SOFTBUS_INVALID_PARAM);
333 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
334 char *msg = JSON_PrintUnformatted(obj);
335 EXPECT_TRUE(UnpackDeviceIdJson(msg, strlen(msg), &info) == SOFTBUS_NOT_FIND);
336 if (msg != nullptr) {
337 JSON_Free(msg);
338 }
339 JSON_Delete(obj);
340 JsonObj *obj1 = JSON_CreateObject();
341 EXPECT_TRUE(obj1 != nullptr);
342 JSON_AddStringToObject(obj1, CMD_TAG, CMD_GET_AUTH_INFO);
343 JSON_AddStringToObject(obj1, DATA_TAG, "123456");
344 JSON_AddStringToObject(obj1, DEVICE_ID_TAG, "654321");
345 JSON_AddInt32ToObject(obj1, DATA_BUF_SIZE_TAG, PACKET_SIZE);
346 JSON_AddInt32ToObject(obj1, SOFTBUS_VERSION_TAG, 123);
347 JSON_AddInt32ToObject(obj1, EXCHANGE_ID_TYPE, EXCHANGE_UDID);
348 JSON_AddStringToObject(obj1, SUPPORT_INFO_COMPRESS, TRUE_STRING_TAG);
349 char *msg1 = JSON_PrintUnformatted(obj1);
350 info.connInfo.type = AUTH_LINK_TYPE_BR;
351 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info) == SOFTBUS_CMP_FAIL);
352 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
353 info.isServer = false;
354 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info) == SOFTBUS_CMP_FAIL);
355 info.isConnectServer = true;
356 EXPECT_TRUE(UnpackDeviceIdJson(msg1, strlen(msg1), &info) == SOFTBUS_OK);
357 if (msg1 != nullptr) {
358 JSON_Free(msg1);
359 }
360 JSON_Delete(obj1);
361 }
362
363 /*
364 * @tc.name: PackCommonDevInfo_TEST_001
365 * @tc.desc: PackCommonDevInfo test
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(AuthSessionMessageTest, PackCommonDevInfo_TEST_001, TestSize.Level1)
370 {
371 JsonObj *json = JSON_CreateObject();
372 EXPECT_TRUE(json != nullptr);
373 NodeInfo info;
374 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
375 EXPECT_TRUE(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, INVALID_UNIFIED_NAME,
376 strlen(INVALID_UNIFIED_NAME)) == EOK);
377 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, INVALID_UDID, strlen(INVALID_UDID)) == EOK);
378 EXPECT_TRUE(PackCommonDevInfo(json, &info, true) == SOFTBUS_OK);
379 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
380 EXPECT_TRUE(memcpy_s(info.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME, strlen(UNIFIED_NAME)) == EOK);
381 EXPECT_TRUE(memcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NETWORK_ID_TEST, strlen(NETWORK_ID_TEST)) == EOK);
382 EXPECT_TRUE(
383 memcpy_s(info.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, DEVICE_NAME_TEST, strlen(DEVICE_NAME_TEST)) == EOK);
384 info.deviceInfo.deviceTypeId = 12;
385 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
386 EXPECT_TRUE(PackCommonDevInfo(json, &info, false) == SOFTBUS_OK);
387 JSON_Delete(json);
388 }
389
390 /*
391 * @tc.name: UnpackCipherRpaInfo_TEST_001
392 * @tc.desc: UnpackCipherRpaInfo test
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(AuthSessionMessageTest, UnpackCipherRpaInfo_TEST_001, TestSize.Level1)
397 {
398 JsonObj *json = JSON_CreateObject();
399 EXPECT_TRUE(json != nullptr);
400 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, "cipherKeyTest");
401 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, "cipherIv");
402 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
403 (void)JSON_AddStringToObject(json, PUB_MAC, "pubMac");
404 NodeInfo info;
405 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
406 EXPECT_TRUE(memcpy_s(info.cipherInfo.key, SESSION_KEY_LENGTH, KEY_TEST, strlen(KEY_TEST)) == EOK);
407 EXPECT_TRUE(memcpy_s(info.cipherInfo.iv, BROADCAST_IV_LEN, IV_TEST, strlen(IV_TEST)) == EOK);
408 EXPECT_TRUE(memcpy_s(info.rpaInfo.peerIrk, LFINDER_IRK_LEN, PEER_IRK, PEER_IRK_LEN) == EOK);
409 EXPECT_TRUE(memcpy_s(info.rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, PUBLIC_ADDRESS, PUBLIC_ADDRESS_LEN) == EOK);
410 UnpackCipherRpaInfo(json, &info);
411 JSON_Delete(json);
412 JsonObj *json1 = JSON_CreateObject();
413 EXPECT_TRUE(json1 != nullptr);
414 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
415 EXPECT_TRUE(PackCommon(json1, &info, SOFTBUS_OLD_V2, false) == SOFTBUS_OK);
416 EXPECT_TRUE(PackCommon(json1, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
417 JSON_Delete(json1);
418 }
419
420 /*
421 * @tc.name: UnpackWifiDirectInfo_TEST_001
422 * @tc.desc: UnpackWifiDirectInfo test
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(AuthSessionMessageTest, UnpackWifiDirectInfo_TEST_001, TestSize.Level1)
427 {
428 JsonObj *json = JSON_CreateObject();
429 EXPECT_TRUE(json != nullptr);
430 (void)JSON_AddStringToObject(json, IRK, "peerIrk");
431 NodeInfo info;
432 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
433 EXPECT_TRUE(memcpy_s(info.staticCapability, STATIC_CAP_LEN, STATIC_CAPABILITY, CAPABILITY_LEN) == EOK);
434 UnpackWifiDirectInfo(json, &info, false);
435 JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, 10);
436 UnpackWifiDirectInfo(json, &info, false);
437 JSON_AddStringToObject(json, STATIC_CAP, "staticCap");
438 UnpackWifiDirectInfo(json, &info, false);
439 JSON_AddStringToObject(json, PTK, "encodePtk");
440 UnpackWifiDirectInfo(json, &info, false);
441 EXPECT_TRUE(memcpy_s(info.remotePtk, PTK_DEFAULT_LEN, REMOTE_PTK, strlen(REMOTE_PTK)) == EOK);
442 UnpackWifiDirectInfo(json, &info, false);
443 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
444 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
445 JSON_AddStringToObject(json, DEVICE_UUID, "123456");
446 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
447 UnpackCommon(json, &info, SOFTBUS_OLD_V1, true);
448 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
449 JSON_AddStringToObject(json, NODE_ADDR, "127.0.0.0");
450 UnpackCommon(json, &info, SOFTBUS_NEW_V1, false);
451 char buf[10] = { 0 };
452 EXPECT_TRUE(GetBtDiscTypeString(nullptr, buf, 10) == SOFTBUS_OK);
453 info.discoveryType = 11;
454 EXPECT_TRUE(GetBtDiscTypeString(&info, buf, 10) == SOFTBUS_OK);
455 info.discoveryType = 15;
456 EXPECT_TRUE(UnpackBt(json, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
457 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 3);
458 EXPECT_TRUE(UnpackBt(json, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
459 EXPECT_TRUE(PackWiFi(json, &info, SOFTBUS_NEW_V1, false) == SOFTBUS_OK);
460 JSON_Delete(json);
461 }
462
463 /*
464 * @tc.name: CheckBusVersion_TEST_001
465 * @tc.desc: CheckBusVersion test
466 * @tc.type: FUNC
467 * @tc.require:
468 */
469 HWTEST_F(AuthSessionMessageTest, CheckBusVersion_TEST_001, TestSize.Level1)
470 {
471 JsonObj *json1 = JSON_CreateObject();
472 EXPECT_TRUE(json1 != nullptr);
473 JSON_AddInt32ToObject(json1, BUS_MAX_VERSION, -1);
474 JSON_AddInt32ToObject(json1, BUS_MIN_VERSION, -1);
475 EXPECT_NE(CheckBusVersion(json1), SOFTBUS_OK);
476 NodeInfo info;
477 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
478 EXPECT_NE(UnpackWiFi(json1, &info, SOFTBUS_OLD_V1, false), SOFTBUS_OK);
479 JSON_Delete(json1);
480 JsonObj *json = JSON_CreateObject();
481 EXPECT_TRUE(json != nullptr);
482 JSON_AddInt32ToObject(json, BUS_MAX_VERSION, 3);
483 JSON_AddInt32ToObject(json, BUS_MIN_VERSION, 0);
484 ;
485 EXPECT_TRUE(CheckBusVersion(json) == 2);
486 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false) == SOFTBUS_OK);
487 JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, 63);
488 JSON_AddStringToObject(json, BLE_OFFLINE_CODE, "123");
489 EXPECT_TRUE(UnpackWiFi(json, &info, SOFTBUS_OLD_V1, false) == SOFTBUS_OK);
490 JSON_Delete(json);
491 }
492
493 /*
494 * @tc.name: PackDeviceInfoBtV1_TEST_001
495 * @tc.desc: PackDeviceInfoBtV1 test
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(AuthSessionMessageTest, PackDeviceInfoBtV1_TEST_001, TestSize.Level1)
500 {
501 NodeInfo info;
502 EXPECT_TRUE(PackDeviceInfoBtV1(nullptr, &info, false) == SOFTBUS_AUTH_PACK_DEVINFO_FAIL);
503 JsonObj *json = JSON_CreateObject();
504 EXPECT_TRUE(json != nullptr);
505 EXPECT_TRUE(PackDeviceInfoBtV1(json, &info, false) == SOFTBUS_OK);
506 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
507 JSON_AddStringToObject(json, DEVICE_NAME, "testname");
508 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
509 JSON_AddStringToObject(json, DEVICE_TYPE, "TV");
510 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
511 JSON_AddStringToObject(json, DEVICE_UDID, "123456");
512 JSON_AddStringToObject(json, UUID, "123456");
513 JSON_AddStringToObject(json, BR_MAC_ADDR, "11:22:33:44:55");
514 JSON_AddInt64ToObject(json, NEW_CONN_CAP, -1);
515 EXPECT_TRUE(UnpackDeviceInfoBtV1(json, &info) == SOFTBUS_OK);
516 JSON_Delete(json);
517 }
518
519 /*
520 * @tc.name: UpdatePeerDeviceName_TEST_001
521 * @tc.desc: UpdatePeerDeviceName test
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 HWTEST_F(AuthSessionMessageTest, UpdatePeerDeviceName_TEST_001, TestSize.Level1)
526 {
527 NodeInfo peerNodeInfo;
528 (void)memset_s(&peerNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
529 UpdatePeerDeviceName(&peerNodeInfo);
530 ASSERT_TRUE(
531 memcpy_s(peerNodeInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME, strlen(UNIFIED_NAME)) == EOK);
532 ASSERT_TRUE(memcpy_s(peerNodeInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, DEVICE_NAME_TEST,
533 strlen(DEVICE_NAME_TEST)) == EOK);
534 UpdatePeerDeviceName(&peerNodeInfo);
535 ASSERT_TRUE(memcpy_s(peerNodeInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, UNIFIED_NAME,
536 strlen(UNIFIED_NAME)) == EOK);
537 UpdatePeerDeviceName(&peerNodeInfo);
538 AuthSessionInfo info;
539 EXPECT_TRUE(PostDeviceIdData(123, &info, nullptr, 0) == SOFTBUS_AUTH_SEND_FAIL);
540 info.isServer = false;
541 EXPECT_NE(PostBtV1DevId(123, &info), SOFTBUS_OK);
542 EXPECT_NE(PostWifiV1DevId(123, &info), SOFTBUS_OK);
543 info.isServer = true;
544 EXPECT_NE(PostBtV1DevId(123, &info), SOFTBUS_OK);
545 EXPECT_NE(PostWifiV1DevId(123, &info), SOFTBUS_OK);
546 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
547 EXPECT_NE(PostDeviceIdV1(123, &info), SOFTBUS_OK);
548 info.connInfo.type = AUTH_LINK_TYPE_BLE;
549 EXPECT_NE(PostDeviceIdV1(123, &info), SOFTBUS_OK);
550 EXPECT_NE(PostDeviceIdNew(123, &info), SOFTBUS_OK);
551 EXPECT_TRUE(PostCloseAckMessage(123, &info) == SOFTBUS_AUTH_SEND_FAIL);
552 }
553
554 /*
555 * @tc.name: ProcessDeviceIdMessage_TEST_001
556 * @tc.desc: ProcessDeviceIdMessage test
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(AuthSessionMessageTest, ProcessDeviceIdMessage_TEST_001, TestSize.Level1)
561 {
562 AuthSessionInfo info;
563 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
564 uint8_t data[] = "test";
565 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN) == SOFTBUS_INVALID_PARAM);
566 info.connInfo.type = AUTH_LINK_TYPE_BLE;
567 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN + 1) == SOFTBUS_INVALID_PARAM);
568 info.isServer = false;
569 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN) == SOFTBUS_INVALID_PARAM);
570 info.isServer = true;
571 EXPECT_TRUE(ProcessDeviceIdMessage(&info, data, DEVICE_ID_STR_LEN) == SOFTBUS_OK);
572 }
573
574 /*
575 * @tc.name: UnpackDeviceInfoMessage_TEST_001
576 * @tc.desc: UnpackDeviceInfoMessage test
577 * @tc.type: FUNC
578 * @tc.require:
579 */
580 HWTEST_F(AuthSessionMessageTest, UnpackDeviceInfoMessage_TEST_001, TestSize.Level1)
581 {
582 DevInfoData devInfo;
583 NodeInfo nodeInfo;
584 AuthSessionInfo info;
585 (void)memset_s(&devInfo, sizeof(DevInfoData), 0, sizeof(DevInfoData));
586 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
587 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
588 JsonObj *obj = JSON_CreateObject();
589 EXPECT_TRUE(obj != nullptr);
590 JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, EXCHANGE_FAIL);
591 char *msg = JSON_PrintUnformatted(obj);
592 devInfo.msg = msg;
593 devInfo.len = strlen(msg);
594 devInfo.linkType = AUTH_LINK_TYPE_BLE;
595 EXPECT_TRUE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info) == SOFTBUS_OK);
596 devInfo.linkType = AUTH_LINK_TYPE_WIFI;
597 nodeInfo.feature = 511;
598 EXPECT_NE(UnpackDeviceInfoMessage(&devInfo, &nodeInfo, false, &info), SOFTBUS_OK);
599 JSON_Delete(obj);
600 }
601
602 /*
603 * @tc.name: IsDeviceMessagePacket_TEST_001
604 * @tc.desc: IsDeviceMessagePacket test
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(AuthSessionMessageTest, IsDeviceMessagePacket_TEST_001, TestSize.Level1)
609 {
610 AuthConnInfo connInfo;
611 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
612 DeviceMessageParse messageParse = { 0 };
613 connInfo.type = AUTH_LINK_TYPE_BLE;
614 EXPECT_TRUE(!IsDeviceMessagePacket(&connInfo, nullptr, nullptr, true, &messageParse));
615 connInfo.type = AUTH_LINK_TYPE_WIFI;
616 EXPECT_TRUE(!IsDeviceMessagePacket(&connInfo, nullptr, nullptr, true, &messageParse));
617 }
618
619 /*
620 * @tc.name: PACK_FAST_AUTH_VALUE_TEST_001
621 * @tc.desc: Pack fast auth value test
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 HWTEST_F(AuthSessionMessageTest, PACK_FAST_AUTH_VALUE_TEST_001, TestSize.Level1)
626 {
627 AuthDeviceKeyInfo deviceCommKey = { 0 };
628 JsonObj *obj = JSON_CreateObject();
629 ASSERT_NE(obj, nullptr);
630 uint32_t keyLen = 0;
631 deviceCommKey.keyLen = keyLen;
632 uint64_t ret = PackFastAuthValue(obj, &deviceCommKey);
633 EXPECT_NE(ret, SOFTBUS_OK);
634 JSON_Delete(obj);
635 }
636
637 /*
638 * @tc.name: CHECK_BUS_VERSION_TEST_001
639 * @tc.desc: check bus version test
640 * @tc.type: FUNC
641 * @tc.require:
642 */
643 HWTEST_F(AuthSessionMessageTest, CHECK_BUS_VERSION_TEST_001, TestSize.Level1)
644 {
645 JsonObj *obj = JSON_CreateObject();
646 if (obj == nullptr) {
647 return;
648 }
649
650 NodeInfo *info = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
651 if (info == nullptr) {
652 JSON_Delete(obj);
653 return;
654 }
655 (void)memset_s(info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
656
657 SoftBusVersion version = SOFTBUS_NEW_V1;
658 if (!JSON_AddInt32ToObject(obj, "CODE", (int32_t)1) || !JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)2) ||
659 !JSON_AddInt32ToObject(obj, "BUS_MIN_VERSION", (int32_t)1) ||
660 !JSON_AddInt32ToObject(obj, "AUTH_PORT", (int32_t)8710) ||
661 !JSON_AddInt32ToObject(obj, "SESSION_PORT", (int32_t)26) ||
662 !JSON_AddInt32ToObject(obj, "PROXY_PORT", (int32_t)80) || !JSON_AddStringToObject(obj, "DEV_IP", "127.0.0.1")) {
663 JSON_Delete(obj);
664 return;
665 }
666 JSON_AddStringToObject(obj, BLE_OFFLINE_CODE, "10244");
667
668 info->connectInfo.authPort = 8710;
669 info->connectInfo.sessionPort = 26;
670 info->connectInfo.proxyPort = 80;
671 info->supportedProtocols = LNN_PROTOCOL_BR;
672
673 int32_t ret = UnpackWiFi(obj, info, version, false);
674 EXPECT_TRUE(ret == SOFTBUS_OK);
675 JSON_AddInt32ToObject(obj, "BUS_MAX_VERSION", (int32_t)-1);
676 ret = UnpackWiFi(obj, info, version, false);
677 EXPECT_NE(ret, SOFTBUS_OK);
678
679 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_KEY", "1222222222");
680 (void)JSON_AddStringToObject(obj, "BROADCAST_CIPHER_IV", "1222222222");
681 (void)JSON_AddStringToObject(obj, "IRK", "1222222222");
682 (void)JSON_AddStringToObject(obj, "PUB_MAC", "1222222222");
683
684 JSON_AddStringToObject(obj, "MASTER_UDID", "1122334554444");
685 JSON_AddStringToObject(obj, "NODE_ADDR", "1122334554444");
686 UnpackCommon(obj, info, version, false);
687 version = SOFTBUS_OLD_V1;
688 JSON_AddInt32ToObject(obj, "MASTER_WEIGHT", (int32_t)10);
689 UnpackCommon(obj, info, version, true);
690 UnpackCipherRpaInfo(obj, info);
691 JSON_Delete(obj);
692 SoftBusFree(info);
693 }
694
695 /*
696 * @tc.name: POST_BT_V1_DEVID_TEST_001
697 * @tc.desc: post bt v1 devid test
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 HWTEST_F(AuthSessionMessageTest, POST_BT_V1_DEVID_TEST_001, TestSize.Level1)
702 {
703 int64_t authSeq = 0;
704 AuthSessionInfo *info = (AuthSessionInfo *)SoftBusCalloc(sizeof(AuthSessionInfo));
705 if (info == nullptr) {
706 return;
707 }
708 info->requestId = 1;
709 info->connId = 1;
710 info->isServer = false;
711 info->version = SOFTBUS_NEW_V1;
712 info->connInfo.type = AUTH_LINK_TYPE_WIFI;
713 int32_t ret = PostDeviceIdV1(authSeq, info);
714 EXPECT_NE(ret, SOFTBUS_OK);
715 SoftBusFree(info);
716 }
717
718 /*
719 * @tc.name: IS_EMPTY_SHORT_HASH_STR_TEST_001
720 * @tc.desc:
721 * @tc.type: FUNC
722 * @tc.require:
723 */
724 HWTEST_F(AuthSessionMessageTest, IS_EMPTY_SHORT_HASH_STR_TEST_001, TestSize.Level1)
725 {
726 char udidHash[SHA_256_HEX_HASH_LEN];
727 const char *udidHash1 = "123456";
728 const char *udidHash2 = "0000000000000000000000000000000000000000000000000000000000000000";
729 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
730 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), "") == EOK);
731 bool ret = IsEmptyShortHashStr(udidHash);
732 EXPECT_EQ(ret, true);
733
734 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
735 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), udidHash1) == EOK);
736 ret = IsEmptyShortHashStr(udidHash);
737 EXPECT_EQ(ret, false);
738
739 (void)memset_s(udidHash, sizeof(udidHash), 0, sizeof(udidHash));
740 EXPECT_TRUE(strcpy_s(udidHash, sizeof(udidHash), udidHash2) == EOK);
741 ret = IsEmptyShortHashStr(udidHash);
742 EXPECT_EQ(ret, true);
743 }
744
745 /*
746 * @tc.name: GET_LOCAL_UDISHASH_TEST_001
747 * @tc.desc:
748 * @tc.type: FUNC
749 * @tc.require:
750 */
751 HWTEST_F(AuthSessionMessageTest, GET_LOCAL_UDISHASH_TEST_001, TestSize.Level1)
752 {
753 int32_t ret = GetLocalUdidHash(nullptr, nullptr, 0);
754 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
755 }
756
757 /*
758 * @tc.name: UPDATE_LOCAL_AUTH_STATE_TEST_001
759 * @tc.desc:
760 * @tc.type: FUNC
761 * @tc.require:
762 */
763 HWTEST_F(AuthSessionMessageTest, UPDATE_LOCAL_AUTH_STATE_TEST_001, TestSize.Level1)
764 {
765 uint64_t authSeq = 512;
766 AuthSessionInfo info;
767 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
768 info.isServer = true;
769 int32_t ret = UpdateLocalAuthState(authSeq, &info);
770 EXPECT_EQ(ret, SOFTBUS_OK);
771
772 info.isServer = false;
773 info.peerState = AUTH_STATE_COMPATIBLE;
774 ret = UpdateLocalAuthState(authSeq, &info);
775 EXPECT_EQ(ret, SOFTBUS_OK);
776
777 info.peerState = AUTH_STATE_ACK;
778 ret = UpdateLocalAuthState(authSeq, &info);
779 EXPECT_EQ(ret, SOFTBUS_OK);
780 }
781
782 /*
783 * @tc.name: PACK_FAST_AUTH_VALUE_TEST_002
784 * @tc.desc: PackFastAuthValue test
785 * @tc.type: FUNC
786 * @tc.require:
787 */
788 HWTEST_F(AuthSessionMessageTest, PACK_FAST_AUTH_VALUE_TEST_002, TestSize.Level1)
789 {
790 JsonObj *obj = JSON_CreateObject();
791 EXPECT_TRUE(obj != nullptr);
792 AuthDeviceKeyInfo deviceCommKey;
793 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
794 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(deviceCommKey.deviceKey, SESSION_KEY_LENGTH));
795 deviceCommKey.keyLen = SESSION_KEY_LENGTH;
796 deviceCommKey.keyIndex = 12345;
797 EXPECT_TRUE(PackFastAuthValue(obj, &deviceCommKey) == SOFTBUS_OK);
798 JSON_Delete(obj);
799 }
800
801 /*
802 * @tc.name: GET_UDID_SHORT_HASH_TEST_001
803 * @tc.desc: GetUdidShortHash test
804 * @tc.type: FUNC
805 * @tc.require:
806 */
807 HWTEST_F(AuthSessionMessageTest, GET_UDID_SHORT_HASH_TEST_001, TestSize.Level1)
808 {
809 AuthSessionInfo info = {
810 .connInfo.type = AUTH_LINK_TYPE_BR,
811 .isServer = true,
812 };
813 uint32_t bufLen = UDID_SHORT_HASH_HEX_STR;
814 char udidHash[SHORT_UDID_HASH_HEX_LEN + 1];
815 EXPECT_EQ(false, GetUdidShortHash(nullptr, nullptr, bufLen));
816 EXPECT_EQ(false, GetUdidShortHash(&info, nullptr, bufLen));
817 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
818 bufLen++;
819 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
820 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
821 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
822 info.connInfo.type = AUTH_LINK_TYPE_BLE;
823 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
824 info.connInfo.type = AUTH_LINK_TYPE_P2P;
825 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
826 info.isServer = false;
827 EXPECT_EQ(false, GetUdidShortHash(&info, udidHash, bufLen));
828 ASSERT_TRUE(memcpy_s(info.udid, UDID_BUF_LEN, UDID, strlen(UDID)) == EOK);
829 EXPECT_EQ(true, GetUdidShortHash(&info, udidHash, bufLen));
830 }
831
832 /*
833 * @tc.name: PACK_NORMALIZED_KEY_VALUE_TEST_001
834 * @tc.desc: PackNormalizedKeyValue test
835 * @tc.type: FUNC
836 * @tc.require:
837 */
838 HWTEST_F(AuthSessionMessageTest, PACK_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
839 {
840 SessionKey sessionKey = {
841 .len = SESSION_KEY_LENGTH,
842 };
843 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
844 JsonObj *obj = JSON_CreateObject();
845 EXPECT_TRUE(obj != nullptr);
846 AuthSessionInfo info = {
847 .isNeedFastAuth = false,
848 .isServer = false,
849 .normalizedType = NORMALIZED_KEY_ERROR,
850 .localState = AUTH_STATE_WAIT,
851 .connInfo.type = AUTH_LINK_TYPE_WIFI,
852 .normalizedKey = nullptr,
853 };
854 PackNormalizedKey(obj, &info);
855 info.isNeedFastAuth = true;
856 PackNormalizedKey(obj, &info);
857 info.isServer = true;
858 PackNormalizedKey(obj, &info);
859 info.normalizedType = NORMALIZED_NOT_SUPPORT;
860 info.localState = AUTH_STATE_START;
861 PackNormalizedKey(obj, &info);
862 info.normalizedKey = &sessionKey;
863 PackNormalizedKey(obj, &info);
864 EXPECT_TRUE(memcpy_s(info.connInfo.info.ipInfo.deviceIdHash, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
865 PackNormalizedKey(obj, &info);
866 EXPECT_EQ(SOFTBUS_OK, PackNormalizedKeyValue(obj, &sessionKey));
867 JSON_Delete(obj);
868 }
869
870 /*
871 * @tc.name: PARSE_NORMALIZED_KEY_VALUE_TEST_001
872 * @tc.desc: ParseNormalizedKeyValue test
873 * @tc.type: FUNC
874 * @tc.require:
875 */
876 HWTEST_F(AuthSessionMessageTest, PARSE_NORMALIZED_KEY_VALUE_TEST_001, TestSize.Level1)
877 {
878 const char *encNormalizedKey = "encnormalizedkeytest";
879 SessionKey sessionKey = {
880 .len = SESSION_KEY_LENGTH,
881 };
882 EXPECT_EQ(SOFTBUS_OK, SoftBusGenerateRandomArray(sessionKey.value, SESSION_KEY_LENGTH));
883 AuthSessionInfo info;
884 EXPECT_NE(SOFTBUS_OK, ParseNormalizedKeyValue(&info, encNormalizedKey, &sessionKey));
885 ASSERT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
886 AuthDeviceKeyInfo deviceKey;
887 EXPECT_NE(SOFTBUS_OK, ParseNormalizeData(&info, const_cast<char *>(encNormalizedKey), &deviceKey));
888 }
889
890 /*
891 * @tc.name: PACK_DEVICE_JSON_INFO_TEST_001
892 * @tc.desc: PackDeviceJsonInfo test
893 * @tc.type: FUNC
894 * @tc.require:
895 */
896 HWTEST_F(AuthSessionMessageTest, PACK_DEVICE_JSON_INFO_TEST_001, TestSize.Level1)
897 {
898 JsonObj *obj = JSON_CreateObject();
899 EXPECT_TRUE(obj != nullptr);
900 SessionKey sessionKey;
901 AuthSessionInfo info = {
902 .connInfo.type = AUTH_LINK_TYPE_WIFI,
903 .isConnectServer = false,
904 .localState = AUTH_STATE_START,
905 .isServer = false,
906 .normalizedKey = &sessionKey,
907 };
908 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
909 const char *encNormalizedKey = "encnormalizedkeytest";
910 EXPECT_EQ(true, JSON_AddStringToObject(obj, NORMALIZED_DATA, encNormalizedKey));
911 UnpackNormalizedKey(obj, &info, NORMALIZED_NOT_SUPPORT);
912 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT);
913 info.isServer = true;
914 info.normalizedKey = nullptr;
915 EXPECT_TRUE(memcpy_s(info.uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
916 UnpackNormalizedKey(obj, &info, NORMALIZED_SUPPORT);
917 info.isConnectServer = true;
918 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
919 info.connInfo.type = AUTH_LINK_TYPE_BLE;
920 EXPECT_EQ(SOFTBUS_OK, PackDeviceJsonInfo(&info, obj));
921 JSON_Delete(obj);
922 }
923
924 /*
925 * @tc.name: PACK_DEVICE_INFO_MESSAGE_TEST_001
926 * @tc.desc: PackDeviceInfoMessage test
927 * @tc.type: FUNC
928 * @tc.require:
929 */
930 HWTEST_F(AuthSessionMessageTest, PACK_CERTIFICATE_INFO_TEST_001, TestSize.Level1)
931 {
932 JsonObj *obj = JSON_CreateObject();
933 EXPECT_TRUE(obj != nullptr);
934 NodeInfo info;
935 const char *staticCap = "staticCapTest";
936 const char *encodePtk = "encodePtkTest";
937 EXPECT_EQ(true, JSON_AddInt32ToObject(obj, STATIC_CAP_LENGTH, DATA_TEST_LEN));
938 EXPECT_EQ(true, JSON_AddStringToObject(obj, STATIC_CAP, staticCap));
939 EXPECT_EQ(true, JSON_AddStringToObject(obj, PTK, encodePtk));
940 UnpackWifiDirectInfo(obj, &info, false);
941 EXPECT_EQ(nullptr, PackDeviceInfoMessage(nullptr, SOFTBUS_NEW_V1, false, nullptr, nullptr));
942 JSON_Delete(obj);
943 }
944
945 /*
946 * @tc.name: GET_DUMP_SESSIONKEY_LIST_TEST_001
947 * @tc.desc: GetDumpSessionKeyList test
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 HWTEST_F(AuthSessionMessageTest, GET_DUMP_SESSIONKEY_LIST_TEST_001, TestSize.Level1)
952 {
953 AuthSessionInfo info;
954 uint64_t connId = 1;
955 int64_t authSeq = 1;
956 SessionKeyList sessionKeyList;
957 info.connId = connId;
958 info.isServer = false;
959 info.isSupportFastAuth = true;
960 info.connInfo.type = AUTH_LINK_TYPE_BLE;
961 info.version = SOFTBUS_OLD_V1;
962 SessionKey sessionKey;
963 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
964 ASSERT_TRUE(memcpy_s(sessionKey.value, SESSION_KEY_LENGTH, KEY_TEST, PEER_IRK_LEN) == EOK);
965 sessionKey.len = PEER_IRK_LEN;
966 EXPECT_TRUE(AuthManagerSetSessionKey(authSeq, &info, &sessionKey, false, false) == SOFTBUS_OK);
967 GetDumpSessionKeyList(authSeq, &info, &sessionKeyList);
968
969 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
970 info.isSupportCompress = true;
971 uint8_t compressData[TEST_DATA_LEN] = { 0 };
972 uint32_t compressLen = TEST_DATA_LEN;
973 char data[TEST_DATA_LEN] = { 0 };
974 InDataInfo inDataInfo;
975 (void)memset_s(&inDataInfo, sizeof(InDataInfo), 0, sizeof(InDataInfo));
976 SetIndataInfo(&inDataInfo, nullptr, 0, data);
977 SetIndataInfo(&inDataInfo, nullptr, compressLen, data);
978 SetIndataInfo(&inDataInfo, compressData, 0, data);
979 }
980 } // namespace OHOS
981