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