1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "auth_log.h"
21 #include "auth_uk_manager.c"
22 #include "auth_uk_manager.h"
23 #include "auth_user_common_key.h"
24 #include "lnn_distributed_net_ledger.h"
25 #include "lnn_local_net_ledger.h"
26 #include "lnn_net_ledger.h"
27 #include "message_handler.h"
28 #include "softbus_adapter_mem.h"
29
30 namespace OHOS {
31 using namespace testing;
32 using namespace testing::ext;
33 constexpr char NODE1_UDID[] = "123456ABCDEF";
34 constexpr char NODE2_UDID[] = "123456ABCDEG";
35 constexpr char NODE1_ACCOUNT_ID[] = "123456ABCDEFACCOUNTID";
36 constexpr char NODE2_ACCOUNT_ID[] = "123456ABCDEGACCOUNTID";
37 constexpr int32_t TEST_DATA_LEN = 9;
38 constexpr char TEST_DATA[] = "testdata";
39 constexpr uint64_t UK_DECAY_TIME = 15552000000;
40
41 class AuthUkManagerTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase()49 void AuthUkManagerTest::SetUpTestCase()
50 {
51 AUTH_LOGI(AUTH_CONN, "AuthUkManagerTest start");
52 int32_t ret = LooperInit();
53 EXPECT_EQ(ret, SOFTBUS_OK);
54 ret = LnnInitLocalLedger();
55 EXPECT_EQ(ret, SOFTBUS_OK);
56 ret = LnnInitDistributedLedger();
57 EXPECT_EQ(ret, SOFTBUS_OK);
58 ret = AuthUserKeyInit();
59 EXPECT_EQ(ret, SOFTBUS_OK);
60 }
61
TearDownTestCase()62 void AuthUkManagerTest::TearDownTestCase()
63 {
64 AUTH_LOGI(AUTH_CONN, "AuthUkManagerTest end");
65 DeinitUserKeyList();
66 LnnDeinitDistributedLedger();
67 LnnDeinitLocalLedger();
68 LooperDeinit();
69 }
70
SetUp()71 void AuthUkManagerTest::SetUp() { }
72
TearDown()73 void AuthUkManagerTest::TearDown() { }
74
75 /*
76 * @tc.name: AUTH_UK_MANAGER_Test_001
77 * @tc.desc: AuthFindUkIdByAclInfo test
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_001, TestSize.Level1)
82 {
83 AuthACLInfo aclInfo = { 0 };
84 int32_t ukId;
85 int32_t ret = AuthFindUkIdByAclInfo(nullptr, &ukId);
86 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
87 ret = AuthFindUkIdByAclInfo(&aclInfo, nullptr);
88 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
89 ret = AuthFindUkIdByAclInfo(&aclInfo, &ukId);
90 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_NOT_FOUND);
91 }
92
93 /*
94 * @tc.name: AUTH_UK_MANAGER_Test_002
95 * @tc.desc: AuthGenUkIdByAclInfo test
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_002, TestSize.Level1)
100 {
101 AuthACLInfo aclInfo = { 0 };
102 uint32_t requestId = 1;
103 AuthGenUkCallback genCb = { 0 };
104 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
105 int32_t ret = AuthGenUkIdByAclInfo(nullptr, requestId, &genCb);
106 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
107 ret = AuthGenUkIdByAclInfo(&aclInfo, requestId, nullptr);
108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
109 ret = AuthGenUkIdByAclInfo(&aclInfo, requestId, &genCb);
110 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
111 }
112
113 /*
114 * @tc.name: AUTH_UK_MANAGER_Test_003
115 * @tc.desc: AuthGetUkEncryptSize test
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_003, TestSize.Level1)
120 {
121 uint32_t inLen = 1;
122 uint32_t ret = AuthGetUkEncryptSize(inLen);
123 EXPECT_EQ(ret, inLen + OVERHEAD_LEN);
124 }
125
126 /*
127 * @tc.name: AUTH_UK_MANAGER_Test_004
128 * @tc.desc: AuthGetUkDecryptSize test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_004, TestSize.Level1)
133 {
134 uint32_t inLen = OVERHEAD_LEN - 1;
135 uint32_t ret = AuthGetUkDecryptSize(inLen);
136 EXPECT_EQ(ret, inLen);
137 inLen = OVERHEAD_LEN;
138 ret = AuthGetUkDecryptSize(inLen);
139 EXPECT_EQ(ret, inLen - OVERHEAD_LEN);
140 }
141
142 /*
143 * @tc.name: AUTH_UK_MANAGER_Test_005
144 * @tc.desc: AuthEncryptByUkId test
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_005, TestSize.Level1)
149 {
150 int32_t ukId = 0;
151 uint8_t *inData = nullptr;
152 inData = static_cast<uint8_t *>(SoftBusCalloc(TEST_DATA_LEN));
153 ASSERT_TRUE(inData != nullptr);
154 int32_t ret = memcpy_s(inData, TEST_DATA_LEN, TEST_DATA, sizeof(TEST_DATA));
155 EXPECT_EQ(ret, EOK);
156 uint32_t inLen = TEST_DATA_LEN;
157 uint8_t outData[TEST_DATA_LEN + OVERHEAD_LEN - 1] = { 0 };
158 uint32_t outLen = TEST_DATA_LEN + OVERHEAD_LEN - 1;
159 ret = AuthEncryptByUkId(ukId, nullptr, inLen, outData, &outLen);
160 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
161 ret = AuthEncryptByUkId(ukId, inData, 0, outData, &outLen);
162 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
163 ret = AuthEncryptByUkId(ukId, inData, inLen, nullptr, &outLen);
164 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
165 ret = AuthEncryptByUkId(ukId, inData, inLen, outData, nullptr);
166 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
167 ret = AuthEncryptByUkId(ukId, inData, inLen, outData, &outLen);
168 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
169 uint8_t outData1[TEST_DATA_LEN + OVERHEAD_LEN] = { 0 };
170 uint32_t outLen1 = TEST_DATA_LEN + OVERHEAD_LEN;
171 ret = AuthEncryptByUkId(ukId, inData, inLen, outData1, &outLen1);
172 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_NOT_FOUND);
173 SoftBusFree(inData);
174 }
175
176 /*
177 * @tc.name: AUTH_UK_MANAGER_Test_006
178 * @tc.desc: AuthDecryptByUkId test
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_006, TestSize.Level1)
183 {
184 int32_t ukId = 1;
185 uint8_t *inData = nullptr;
186 inData = static_cast<uint8_t *>(SoftBusCalloc(TEST_DATA_LEN));
187 ASSERT_TRUE(inData != nullptr);
188 int32_t ret = memcpy_s(inData, TEST_DATA_LEN, TEST_DATA, sizeof(TEST_DATA));
189 EXPECT_EQ(ret, EOK);
190 uint32_t inLen = TEST_DATA_LEN;
191 uint8_t outData[SESSION_KEY_LENGTH] = { 0 };
192 uint32_t outLen = SESSION_KEY_LENGTH;
193 ret = AuthDecryptByUkId(ukId, nullptr, inLen, outData, &outLen);
194 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
195 ret = AuthDecryptByUkId(ukId, inData, inLen, outData, &outLen);
196 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
197 inLen = OVERHEAD_LEN;
198 ret = AuthDecryptByUkId(ukId, inData, inLen, nullptr, &outLen);
199 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
200 ret = AuthDecryptByUkId(ukId, inData, inLen, outData, nullptr);
201 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
202 uint8_t *inData1 = nullptr;
203 inData1 = static_cast<uint8_t *>(SoftBusCalloc(inLen));
204 ret = AuthDecryptByUkId(ukId, inData1, inLen, outData, &outLen);
205 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_NOT_FOUND);
206 SoftBusFree(inData);
207 SoftBusFree(inData1);
208 }
209
210 /*
211 * @tc.name: AUTH_UK_MANAGER_Test_007
212 * @tc.desc: GenUkSeq test
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_007, TestSize.Level1)
217 {
218 uint32_t ret = GenUkSeq();
219 EXPECT_GT(ret, 0);
220 }
221
222 /*
223 * @tc.name: COMPARE_BY_ALL_ACL_Test_001
224 * @tc.desc: CompareByAllAcl test
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(AuthUkManagerTest, COMPARE_BY_ALL_ACL_Test_001, TestSize.Level1)
229 {
230 AuthACLInfo oldAcl = {
231 .isServer = false,
232 .sinkUserId = 1,
233 .sourceUserId = 2,
234 .sourceTokenId = 3,
235 .sinkTokenId = 4,
236 };
237 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
238 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
239 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
240 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
241 AuthACLInfo newAcl = {
242 .isServer = false,
243 .sinkUserId = 1,
244 .sourceUserId = 2,
245 .sourceTokenId = 3,
246 .sinkTokenId = 4,
247 };
248 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
249 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
250 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
251 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
252 bool ret = CompareByAllAcl(&oldAcl, &newAcl, false);
253 EXPECT_EQ(ret, false);
254 ret = CompareByAllAcl(&oldAcl, &newAcl, true);
255 EXPECT_EQ(ret, true);
256 }
257
258 /*
259 * @tc.name: COMPARE_BY_ACL_DIFF_ACCOUNT_WITH_USERKEY_Test_001
260 * @tc.desc: CompareByAclDiffAccountWithUserLevel test
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(AuthUkManagerTest, COMPARE_BY_ACL_DIFF_ACCOUNT_WITH_USERKEY_Test_001, TestSize.Level1)
265 {
266 AuthACLInfo oldAcl = {
267 .isServer = false,
268 .sinkUserId = 1,
269 .sourceUserId = 2,
270 .sourceTokenId = 3,
271 .sinkTokenId = 4,
272 };
273 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
274 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
275 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
276 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
277 AuthACLInfo newAcl = {
278 .isServer = false,
279 .sinkUserId = 1,
280 .sourceUserId = 2,
281 .sourceTokenId = 3,
282 .sinkTokenId = 4,
283 };
284 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
285 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
286 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
287 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
288 bool ret = CompareByAclDiffAccountWithUserLevel(&oldAcl, &newAcl, false);
289 EXPECT_EQ(ret, false);
290 ret = CompareByAclDiffAccount(nullptr, nullptr, false);
291 EXPECT_EQ(ret, false);
292 ret = CompareByAclDiffAccount(&oldAcl, nullptr, false);
293 EXPECT_EQ(ret, false);
294 ret = CompareByAclDiffAccountWithUserLevel(&oldAcl, &newAcl, true);
295 EXPECT_EQ(ret, true);
296 }
297
298 /*
299 * @tc.name: COMPARE_BY_ACL_DIFF_ACCOUNT_Test_001
300 * @tc.desc: CompareByAclDiffAccount test
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(AuthUkManagerTest, COMPARE_BY_ACL_DIFF_ACCOUNT_Test_001, TestSize.Level1)
305 {
306 AuthACLInfo oldAcl = {
307 .isServer = false,
308 .sinkUserId = 1,
309 .sourceUserId = 2,
310 .sourceTokenId = 3,
311 .sinkTokenId = 4,
312 };
313 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
314 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
315 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
316 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
317 AuthACLInfo newAcl = {
318 .isServer = false,
319 .sinkUserId = 1,
320 .sourceUserId = 2,
321 .sourceTokenId = 3,
322 .sinkTokenId = 4,
323 };
324 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
325 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
326 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
327 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
328 bool ret = CompareByAclDiffAccount(&oldAcl, &newAcl, false);
329 EXPECT_EQ(ret, false);
330 ret = CompareByAclDiffAccount(&oldAcl, &newAcl, true);
331 EXPECT_EQ(ret, true);
332 }
333
334 /*
335 * @tc.name: COMPARE_BY_ACL_SAME_ACCOUNT_Test_001
336 * @tc.desc: CompareByAclSameAccount test
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(AuthUkManagerTest, COMPARE_BY_ACL_SAME_ACCOUNT_Test_001, TestSize.Level1)
341 {
342 AuthACLInfo oldAcl = {
343 .isServer = false,
344 .sinkUserId = 1,
345 .sourceUserId = 2,
346 .sourceTokenId = 3,
347 .sinkTokenId = 4,
348 };
349 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
350 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
351 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
352 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
353 AuthACLInfo newAcl = {
354 .isServer = false,
355 .sinkUserId = 1,
356 .sourceUserId = 2,
357 .sourceTokenId = 3,
358 .sinkTokenId = 4,
359 };
360 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
361 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
362 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
363 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
364 bool ret = CompareByAclSameAccount(&oldAcl, &newAcl, false);
365 EXPECT_EQ(ret, false);
366 ret = CompareByAclSameAccount(nullptr, nullptr, false);
367 EXPECT_EQ(ret, false);
368 ret = CompareByAclSameAccount(&oldAcl, nullptr, false);
369 EXPECT_EQ(ret, false);
370 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
371 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
372 ret = CompareByAclSameAccount(&oldAcl, &newAcl, true);
373 EXPECT_EQ(ret, true);
374 }
375
376 /*
377 * @tc.name: AUTH_UK_MANAGER_Test_011
378 * @tc.desc: CompareByAllAcl test
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(AuthUkManagerTest, AUTH_UK_MANAGER_Test_011, TestSize.Level1)
383 {
384 AuthACLInfo oldAcl = {
385 .isServer = false,
386 .sinkUserId = 1,
387 .sourceUserId = 2,
388 .sourceTokenId = 3,
389 .sinkTokenId = 4,
390 };
391 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
392 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
393 EXPECT_EQ(EOK, strcpy_s(oldAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
394 EXPECT_EQ(EOK, strcpy_s(oldAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
395 AuthACLInfo newAcl = {
396 .isServer = false,
397 .sinkUserId = 1,
398 .sourceUserId = 2,
399 .sourceTokenId = 3,
400 .sinkTokenId = 4,
401 };
402 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
403 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
404 EXPECT_EQ(EOK, strcpy_s(newAcl.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
405 EXPECT_EQ(EOK, strcpy_s(newAcl.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
406 bool ret = CompareByAllAcl(&oldAcl, &newAcl, false);
407 EXPECT_EQ(ret, false);
408 ret = CompareByAllAcl(nullptr, nullptr, false);
409 EXPECT_EQ(ret, false);
410 ret = CompareByAllAcl(&oldAcl, nullptr, false);
411 EXPECT_EQ(ret, false);
412 ret = CompareByAllAcl(&oldAcl, &newAcl, true);
413 EXPECT_EQ(ret, true);
414 }
415
416 /*
417 * @tc.name: AUTH_UK_MANAGER_Test_012
418 * @tc.desc: AuthIsUkExpired test
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(AuthUkManagerTest, AUTH_IS_UK_EXPIRED_Test_001, TestSize.Level1)
423 {
424 bool ret = AuthIsUkExpired(0);
425 EXPECT_EQ(ret, false);
426 uint64_t currentTime = SoftBusGetSysTimeMs();
427 ret = AuthIsUkExpired(currentTime - UK_DECAY_TIME + 1);
428 EXPECT_EQ(ret, true);
429 }
430
431 /*
432 * @tc.name: UK_NEGOTIATE_INIT_Test_001
433 * @tc.desc: UkNegotiateInit test
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(AuthUkManagerTest, UK_NEGOTIATE_INIT_Test_001, TestSize.Level1)
438 {
439 int32_t ret = UkNegotiateInit();
440 EXPECT_EQ(ret, SOFTBUS_OK);
441 }
442
443 /*
444 * @tc.name: UK_NEGOTIATE_DEINIT_Test_001
445 * @tc.desc: UkNegotiateDeinit test
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 HWTEST_F(AuthUkManagerTest, UK_NEGOTIATE_DEINIT_Test_001, TestSize.Level1)
450 {
451 EXPECT_NO_FATAL_FAILURE(UkNegotiateDeinit());
452 }
453
454 /*
455 * @tc.name: UK_NEGOTIATE_SESSION_INIT_Test_001
456 * @tc.desc: UkNegotiateSessionInit test
457 * @tc.type: FUNC
458 * @tc.require:
459 */
460 HWTEST_F(AuthUkManagerTest, UK_NEGOTIATE_SESSION_INIT_Test_001, TestSize.Level1)
461 {
462 EXPECT_NO_FATAL_FAILURE(UkNegotiateSessionInit());
463 }
464
465 /*
466 * @tc.name: GET_SHORT_UDID_HASH_Test_001
467 * @tc.desc: GetShortUdidHash test
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(AuthUkManagerTest, GET_SHORT_UDID_HASH_Test_001, TestSize.Level1)
472 {
473 char udid[SHA_256_HEX_HASH_LEN] = {0};
474 char udidHash[SHA_256_HEX_HASH_LEN] = {0};
475 uint32_t len = 0;
476
477 int32_t ret = GetShortUdidHash(nullptr, nullptr, len);
478 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
479 ret = GetShortUdidHash(nullptr, nullptr, SHA_256_HEX_HASH_LEN);
480 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
481 ret = GetShortUdidHash(nullptr, udidHash, SHA_256_HEX_HASH_LEN);
482 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
483 ret = GetShortUdidHash(udid, nullptr, len);
484 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
485 (void)strcpy_s(udid, SHA_256_HEX_HASH_LEN, "0123456789ABCDEFG");
486 ret = GetShortUdidHash(udid, udidHash, SHA_256_HEX_HASH_LEN);
487 EXPECT_EQ(ret, SOFTBUS_OK);
488 }
489
490 /*
491 * @tc.name: GET_UK_NEGO_AUTH_PARAM_INFO_Test_001
492 * @tc.desc: GetUkNegoAuthParamInfo test
493 * @tc.type: FUNC
494 * @tc.require:
495 */
496 HWTEST_F(AuthUkManagerTest, GET_UK_NEGO_AUTH_PARAM_INFO_Test_001, TestSize.Level1)
497 {
498 HiChainAuthParam authParam;
499 AuthACLInfo info;
500
501 (void)memset_s(&authParam, sizeof(HiChainAuthParam), 0, sizeof(HiChainAuthParam));
502 (void)memset_s(&info, sizeof(AuthACLInfo), 0, sizeof(AuthACLInfo));
503 int32_t ret = GetUkNegoAuthParamInfo(nullptr, HICHAIN_AUTH_DEVICE, nullptr);
504 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
505 ret = GetUkNegoAuthParamInfo(&info, HICHAIN_AUTH_DEVICE, nullptr);
506 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
507 ret = GetUkNegoAuthParamInfo(nullptr, HICHAIN_AUTH_DEVICE, &authParam);
508 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
509 ret = GetUkNegoAuthParamInfo(&info, HICHAIN_AUTH_DEVICE, &authParam);
510 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
511 }
512
513 /*
514 * @tc.name: UK_MSG_HANDLER_Test_001
515 * @tc.desc: UkMsgHandler test
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(AuthUkManagerTest, UK_MSG_HANDLER_Test_001, TestSize.Level1)
520 {
521 int32_t channelId = 0;
522 uint32_t requestId = 0;
523 AuthDataHead head;
524
525 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
526 int32_t ret = UkMsgHandler(channelId, requestId, nullptr, nullptr, TEST_DATA_LEN);
527 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
528 ret = UkMsgHandler(channelId, requestId, nullptr, TEST_DATA, TEST_DATA_LEN);
529 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
530 ret = UkMsgHandler(channelId, requestId, &head, nullptr, TEST_DATA_LEN);
531 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
532 head.dataType = DATA_TYPE_DEVICE_ID;
533 ret = UkMsgHandler(channelId, requestId, &head, TEST_DATA, TEST_DATA_LEN);
534 EXPECT_EQ(ret, SOFTBUS_CREATE_JSON_ERR);
535 head.dataType = DATA_TYPE_AUTH;
536 ret = UkMsgHandler(channelId, requestId, &head, TEST_DATA, TEST_DATA_LEN);
537 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
538 head.dataType = DATA_TYPE_CLOSE_ACK;
539 ret = UkMsgHandler(channelId, requestId, &head, TEST_DATA, TEST_DATA_LEN);
540 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
541 head.dataType = DATA_TYPE_DECRYPT_FAIL;
542 ret = UkMsgHandler(channelId, requestId, &head, TEST_DATA, TEST_DATA_LEN);
543 EXPECT_EQ(ret, SOFTBUS_CHANNEL_AUTH_HANDLE_DATA_FAIL);
544 }
545
OnGenSuccessTest(uint32_t requestId,int32_t ukId)546 static void OnGenSuccessTest(uint32_t requestId, int32_t ukId)
547 {
548 AUTH_LOGI(AUTH_CONN, "OnGenSuccessTest called");
549 (void)requestId;
550 (void)ukId;
551 }
552
OnGenFailedTest(uint32_t requestId,int32_t reason)553 static void OnGenFailedTest(uint32_t requestId, int32_t reason)
554 {
555 AUTH_LOGI(AUTH_CONN, "OnGenFailedTest called");
556 (void)requestId;
557 (void)reason;
558 }
559
560 /*
561 * @tc.name: CREATE_UK_NEGOTIATE_INSTANCE_Test_001
562 * @tc.desc: CreateUkNegotiateInstance test
563 * @tc.type: FUNC
564 * @tc.require:
565 */
566 HWTEST_F(AuthUkManagerTest, CREATE_UK_NEGOTIATE_INSTANCE_Test_001, TestSize.Level1)
567 {
568 uint32_t requestId = 0;
569 uint32_t channelId = 0;
570 AuthACLInfo info;
571 UkNegotiateInstance instance;
572 AuthGenUkCallback genCb = {
573 .onGenSuccess = OnGenSuccessTest,
574 .onGenFailed = OnGenFailedTest,
575 };
576
577 (void)memset_s(&info, sizeof(AuthACLInfo), 0, sizeof(AuthACLInfo));
578 (void)memset_s(&instance, sizeof(UkNegotiateInstance), 0, sizeof(UkNegotiateInstance));
579 int32_t ret = CreateUkNegotiateInstance(requestId, channelId, &info, &genCb);
580 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
581 ret = InitUkNegoInstanceList();
582 EXPECT_EQ(ret, SOFTBUS_OK);
583 ret = CreateUkNegotiateInstance(requestId, channelId, &info, &genCb);
584 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
585 ret = UkNegotiateInit();
586 EXPECT_EQ(ret, SOFTBUS_OK);
587 ret = CreateUkNegotiateInstance(requestId, channelId, &info, &genCb);
588 EXPECT_EQ(ret, SOFTBUS_OK);
589 ret = UpdateUkNegotiateInfo(requestId, &instance);
590 EXPECT_EQ(ret, SOFTBUS_OK);
591 DeleteUkNegotiateInstance(requestId);
592 DeInitUkNegoInstanceList();
593 UkNegotiateDeinit();
594 }
595
596 /*
597 * @tc.name: PACK_UK_ACL_PARAM_Test_001
598 * @tc.desc: PackUkAclParam test
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(AuthUkManagerTest, PACK_UK_ACL_PARAM_Test_001, TestSize.Level1)
603 {
604 AuthACLInfo info;
605 (void)memset_s(&info, sizeof(AuthACLInfo), 0, sizeof(AuthACLInfo));
606 char *data = PackUkAclParam(&info, true);
607 EXPECT_NE(data, nullptr);
608 int32_t ret = UnpackUkAclParam(data, sizeof(AuthACLInfo), &info);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610 }
611
CreateUkNegotiateInstanceInner(void)612 static int32_t CreateUkNegotiateInstanceInner(void)
613 {
614 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
615 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
616 uint32_t requestId = 1;
617 uint32_t channelId = 1;
618 AuthACLInfo info = {
619 .isServer = false,
620 .sinkUserId = 1,
621 .sourceUserId = 2,
622 .sourceTokenId = 3,
623 .sinkTokenId = 4,
624 };
625 EXPECT_EQ(EOK, strcpy_s(info.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
626 EXPECT_EQ(EOK, strcpy_s(info.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
627 EXPECT_EQ(EOK, strcpy_s(info.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
628 EXPECT_EQ(EOK, strcpy_s(info.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
629 AuthGenUkCallback genCb = {
630 .onGenSuccess = OnGenSuccessTest,
631 .onGenFailed = OnGenFailedTest,
632 };
633 return CreateUkNegotiateInstance(requestId, channelId, &info, &genCb);
634 }
635
636 /*
637 * @tc.name: GET_GEN_UK_INSTANCE_BY_CHANNEL_Test_001
638 * @tc.desc: GetGenUkInstanceByChannel test
639 * @tc.type: FUNC
640 * @tc.require:
641 */
642 HWTEST_F(AuthUkManagerTest, GET_GEN_UK_INSTANCE_BY_CHANNEL_Test_001, TestSize.Level1)
643 {
644 int32_t channelId = 0;
645 uint32_t requestId = 1;
646 UkNegotiateInstance instance;
647 (void)memset_s(&instance, sizeof(UkNegotiateInstance), 0, sizeof(UkNegotiateInstance));
648 int32_t ret = GetGenUkInstanceByChannel(channelId, &instance);
649 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
650 ret = GetGenUkInstanceByChannel(channelId, nullptr);
651 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
652 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
653 ret = GetGenUkInstanceByChannel(channelId, &instance);
654 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
655 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
656 ret = GetGenUkInstanceByChannel(channelId, &instance);
657 EXPECT_EQ(ret, SOFTBUS_AUTH_UK_INSTANCE_NOT_FIND);
658 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
659 channelId = 1;
660 ret = GetGenUkInstanceByChannel(channelId, &instance);
661 EXPECT_EQ(ret, SOFTBUS_OK);
662 DeleteUkNegotiateInstance(requestId);
663 DeInitUkNegoInstanceList();
664 UkNegotiateDeinit();
665 }
666
667 /*
668 * @tc.name: GET_SAME_UK_INSTANCE_NUM_Test_001
669 * @tc.desc: GetSameUkInstanceNum test
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(AuthUkManagerTest, GET_SAME_UK_INSTANCE_NUM_Test_001, TestSize.Level1)
674 {
675 AuthACLInfo info = {
676 .isServer = false,
677 .sinkUserId = 1,
678 .sourceUserId = 2,
679 .sourceTokenId = 3,
680 .sinkTokenId = 4,
681 };
682 EXPECT_EQ(EOK, strcpy_s(info.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
683 EXPECT_EQ(EOK, strcpy_s(info.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
684 EXPECT_EQ(EOK, strcpy_s(info.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
685 EXPECT_EQ(EOK, strcpy_s(info.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
686 uint32_t ret = GetSameUkInstanceNum(&info);
687 EXPECT_EQ(ret, SOFTBUS_OK);
688 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
689 ret = GetSameUkInstanceNum(&info);
690 EXPECT_EQ(ret, SOFTBUS_OK);
691 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
692 uint32_t requestId = 1;
693 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
694 ret = GetSameUkInstanceNum(&info);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 DeleteUkNegotiateInstance(requestId);
697 DeInitUkNegoInstanceList();
698 UkNegotiateDeinit();
699 }
700
701 /*
702 * @tc.name: GET_GEN_UK_INSTANCE_BY_REQ_Test_001
703 * @tc.desc: GetGenUkInstanceByReq test
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(AuthUkManagerTest, GET_GEN_UK_INSTANCE_BY_REQ_Test_001, TestSize.Level1)
708 {
709 uint32_t requestId = 0;
710 UkNegotiateInstance instance;
711 (void)memset_s(&instance, sizeof(UkNegotiateInstance), 0, sizeof(UkNegotiateInstance));
712 int32_t ret = GetGenUkInstanceByReq(requestId, &instance);
713 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
714 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
715 ret = GetGenUkInstanceByReq(requestId, &instance);
716 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
717 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
718 ret = GetGenUkInstanceByReq(requestId, &instance);
719 EXPECT_EQ(ret, SOFTBUS_AUTH_UK_INSTANCE_NOT_FIND);
720 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
721 requestId = 1;
722 ret = GetGenUkInstanceByReq(requestId, &instance);
723 EXPECT_EQ(ret, SOFTBUS_OK);
724 const uint8_t *data = reinterpret_cast<const uint8_t *>("123456");
725 uint32_t len = strlen("123456");
726 bool res = OnTransmitted(requestId, data, len);
727 EXPECT_EQ(res, false);
728 res = OnTransmitted(requestId, nullptr, len);
729 EXPECT_EQ(res, false);
730 DeleteUkNegotiateInstance(requestId);
731 DeInitUkNegoInstanceList();
732 UkNegotiateDeinit();
733 }
734
735 /*
736 * @tc.name: GET_UK_NEGOTIATE_INFO_Test_001
737 * @tc.desc: GetUkNegotiateInfo test
738 * @tc.type: FUNC
739 * @tc.require:
740 */
741 HWTEST_F(AuthUkManagerTest, GET_UK_NEGOTIATE_INFO_Test_001, TestSize.Level1)
742 {
743 uint32_t requestId = 0;
744 UkNegotiateInfo *info = GetUkNegotiateInfo(requestId);
745 EXPECT_EQ(info, nullptr);
746 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
747 info = GetUkNegotiateInfo(requestId);
748 EXPECT_EQ(info, nullptr);
749 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
750 requestId = 1;
751 info = GetUkNegotiateInfo(requestId);
752 EXPECT_NE(info, nullptr);
753 }
754
755 /*
756 * @tc.name: UPDATE_UK_NEGOTIATE_INFO_Test_001
757 * @tc.desc: UpdateUkNegotiateInfo test
758 * @tc.type: FUNC
759 * @tc.require:
760 */
761 HWTEST_F(AuthUkManagerTest, UPDATE_UK_NEGOTIATE_INFO_Test_001, TestSize.Level1)
762 {
763 uint32_t requestId = 0;
764 UkNegotiateInstance instance = { 0 };
765 EXPECT_NO_FATAL_FAILURE(DeleteUkNegotiateInstance(requestId));
766 int32_t ret = UpdateUkNegotiateInfo(requestId, &instance);
767 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_SET_CHANNEL_FAIL);
768 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
769 EXPECT_NO_FATAL_FAILURE(DeleteUkNegotiateInstance(requestId));
770 ret = UpdateUkNegotiateInfo(requestId, nullptr);
771 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
772 ret = UpdateUkNegotiateInfo(requestId, &instance);
773 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_SET_CHANNEL_FAIL);
774 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
775 ret = UpdateUkNegotiateInfo(requestId, &instance);
776 EXPECT_EQ(ret, SOFTBUS_AUTH_ACL_SET_CHANNEL_FAIL);
777 }
778 /*
779 * @tc.name: ASYNC_CALL_GEN_UK_RESULT_RECEIVED_Test_001
780 * @tc.desc: AsyncCallGenUkResultReceived test
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 HWTEST_F(AuthUkManagerTest, ASYNC_CALL_GEN_UK_RESULT_RECEIVED_Test_001, TestSize.Level1)
785 {
786 SyncGenUkResult *res = (SyncGenUkResult*)SoftBusMalloc(sizeof(SyncGenUkResult));
787 ASSERT_TRUE(res != nullptr);
788 res->requestId = 0;
789 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
790 EXPECT_NO_FATAL_FAILURE(AsyncCallGenUkResultReceived(nullptr));
791 EXPECT_NO_FATAL_FAILURE(AsyncCallGenUkResultReceived(reinterpret_cast<void *>(res)));
792 SyncGenUkResult *res1 = (SyncGenUkResult*)SoftBusMalloc(sizeof(SyncGenUkResult));
793 ASSERT_TRUE(res1 != nullptr);
794 res1->requestId = 1;
795 res1->isGenUkSuccess = true;
796 EXPECT_NO_FATAL_FAILURE(AsyncCallGenUkResultReceived(reinterpret_cast<void *>(res1)));
797 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
798 SyncGenUkResult *res2 = (SyncGenUkResult*)SoftBusMalloc(sizeof(SyncGenUkResult));
799 ASSERT_TRUE(res2 != nullptr);
800 res2->requestId = 1;
801 res2->isGenUkSuccess = false;
802 EXPECT_NO_FATAL_FAILURE(AsyncCallGenUkResultReceived(reinterpret_cast<void *>(res2)));
803 DeleteUkNegotiateInstance(res2->requestId = 1);
804 DeInitUkNegoInstanceList();
805 UkNegotiateDeinit();
806 }
807
808 /*
809 * @tc.name: UPDATE_ALL_GEN_CB_CALLBACK_Test_001
810 * @tc.desc: UpdateAllGenCbCallback test
811 * @tc.type: FUNC
812 * @tc.require:
813 */
814 HWTEST_F(AuthUkManagerTest, UPDATE_ALL_GEN_CB_CALLBACK_Test_001, TestSize.Level1)
815 {
816 AuthACLInfo info = {
817 .isServer = false,
818 .sinkUserId = 1,
819 .sourceUserId = 2,
820 .sourceTokenId = 3,
821 .sinkTokenId = 4,
822 };
823 EXPECT_EQ(EOK, strcpy_s(info.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
824 EXPECT_EQ(EOK, strcpy_s(info.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
825 EXPECT_EQ(EOK, strcpy_s(info.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
826 EXPECT_EQ(EOK, strcpy_s(info.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
827 bool isSuccess = true;
828 int32_t reason = SOFTBUS_AUTH_UK_INSTANCE_NOT_FIND;
829 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, isSuccess, reason, 0));
830 EXPECT_EQ(InitUkNegoInstanceList(), SOFTBUS_OK);
831 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, isSuccess, reason, 0));
832 EXPECT_EQ(UkNegotiateInit(), SOFTBUS_OK);
833 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, isSuccess, reason, 0));
834 uint32_t requestId = 1;
835 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
836 EXPECT_NO_FATAL_FAILURE(UpdateAllGenCbCallback(&info, isSuccess, reason, 0));
837 EXPECT_NO_FATAL_FAILURE(OnGenSuccess(reason));
838 DeleteUkNegotiateInstance(requestId);
839 DeInitUkNegoInstanceList();
840 UkNegotiateDeinit();
841 }
842
843 /*
844 * @tc.name: JUDGE_IS_SAME_ACCOUNT_Test_001
845 * @tc.desc: JudgeIsSameAccount test
846 * @tc.type: FUNC
847 * @tc.require:
848 */
849 HWTEST_F(AuthUkManagerTest, JUDGE_IS_SAME_ACCOUNT_Test_001, TestSize.Level1)
850 {
851 char accountHashStr[SHA_256_HEX_HASH_LEN] = { 0 };
852 bool isSameAccount = JudgeIsSameAccount(accountHashStr);
853 EXPECT_EQ(isSameAccount, true);
854 }
855
856 /*
857 * @tc.name: GET_CRED_ID_BY_ID_SERVICE_Test_001
858 * @tc.desc: GetCredIdByIdService test
859 * @tc.type: FUNC
860 * @tc.require:
861 */
862 HWTEST_F(AuthUkManagerTest, GET_CRED_ID_BY_ID_SERVICE_Test_001, TestSize.Level1)
863 {
864 const char *localUdidHash = "5fec";
865 const char *remoteUdidHash = "5fec";
866 const char *accountHash = "accountTest";
867 int32_t userId = 100;
868 char *ptr = GetCredIdByIdService(const_cast<char *>(localUdidHash),
869 const_cast<char *>(remoteUdidHash), const_cast<char *>(accountHash), userId);
870 EXPECT_EQ(ptr, nullptr);
871 }
872
873 /*
874 * @tc.name: GENERATE_AUTH_PARAM_Test_001
875 * @tc.desc: GenerateAuthParam test
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(AuthUkManagerTest, GENERATE_AUTH_PARAM_Test_001, TestSize.Level1)
880 {
881 NodeInfo localNodeInfo;
882 (void)memset_s(&localNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
883 EXPECT_EQ(strcpy_s(localNodeInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID), EOK);
884 NodeInfo remoteNodeInfo;
885 (void)memset_s(&remoteNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
886 EXPECT_EQ(strcpy_s(remoteNodeInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE2_UDID), EOK);
887 AuthACLInfo info = { 0 };
888 info.sinkUserId = 1;
889 info.isServer = true;
890 EXPECT_EQ(EOK, strcpy_s(info.sinkUdid, UDID_BUF_LEN, NODE1_UDID));
891 EXPECT_EQ(EOK, strcpy_s(info.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
892 HiChainAuthMode authMode = HICHAIN_AUTH_IDENTITY_SERVICE;
893 HiChainAuthParam authParam;
894 (void)memset_s(&authParam, sizeof(HiChainAuthParam), 0, sizeof(HiChainAuthParam));
895 int32_t ret = GenerateAuthParam(nullptr, &remoteNodeInfo, &info, authMode, &authParam);
896 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
897 ret = GenerateAuthParam(&localNodeInfo, nullptr, &info, authMode, &authParam);
898 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
899 ret = GenerateAuthParam(&localNodeInfo, &remoteNodeInfo, nullptr, authMode, &authParam);
900 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
901 ret = GenerateAuthParam(&localNodeInfo, &remoteNodeInfo, &info, authMode, nullptr);
902 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
903 ret = GenerateAuthParam(&localNodeInfo, &remoteNodeInfo, &info, authMode, &authParam);
904 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_CRED_ID_FAIL);
905 authMode = HICHAIN_AUTH_DEVICE;
906 ret = GenerateAuthParam(&localNodeInfo, &remoteNodeInfo, &info, authMode, &authParam);
907 EXPECT_EQ(ret, SOFTBUS_OK);
908 }
909
910 /*
911 * @tc.name: ON_SESSION_KEY_RETURNED_Test_001
912 * @tc.desc: OnSessionKeyReturned test
913 * @tc.type: FUNC
914 * @tc.require:
915 */
916 HWTEST_F(AuthUkManagerTest, ON_SESSION_KEY_RETURNED_Test_001, TestSize.Level1)
917 {
918 uint32_t requestId = 0;
919 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
920 const uint8_t *sessionKey = reinterpret_cast<const uint8_t *>("123456789");
921 uint32_t sessionKeyLen = strlen("123456789");
922 EXPECT_NO_FATAL_FAILURE(OnSessionKeyReturned(requestId, nullptr, sessionKeyLen));
923 EXPECT_NO_FATAL_FAILURE(OnSessionKeyReturned(requestId, sessionKey, SESSION_KEY_LENGTH + 1));
924 EXPECT_NO_FATAL_FAILURE(OnSessionKeyReturned(requestId, sessionKey, sessionKeyLen));
925 requestId = 1;
926 EXPECT_NO_FATAL_FAILURE(OnSessionKeyReturned(requestId, sessionKey, sessionKeyLen));
927 DeleteUkNegotiateInstance(requestId);
928 DeInitUkNegoInstanceList();
929 UkNegotiateDeinit();
930 }
931
932 /*
933 * @tc.name: ON_FINISHED_Test_001
934 * @tc.desc: OnFinished test
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(AuthUkManagerTest, ON_FINISHED_Test_001, TestSize.Level1)
939 {
940 uint32_t requestId = 0;
941 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
942 int32_t operationCode = 1;
943 const char *returnData = "returnData";
944 EXPECT_NO_FATAL_FAILURE(OnFinished(requestId, operationCode, returnData));
945 requestId = 1;
946 EXPECT_NO_FATAL_FAILURE(OnFinished(requestId, operationCode, returnData));
947 DeleteUkNegotiateInstance(requestId);
948 DeInitUkNegoInstanceList();
949 UkNegotiateDeinit();
950 }
951
952 /*
953 * @tc.name: ON_ERROR_Test_001
954 * @tc.desc: OnError test
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(AuthUkManagerTest, ON_ERROR_Test_001, TestSize.Level1)
959 {
960 uint32_t authSeq = 0;
961 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
962 int32_t operationCode = 1;
963 int32_t errCode = SOFTBUS_INVALID_PARAM;
964 const char *errorReturn = "errorReturn";
965 EXPECT_NO_FATAL_FAILURE(OnError(authSeq, operationCode, errCode, errorReturn));
966 authSeq = 1;
967 EXPECT_NO_FATAL_FAILURE(OnError(authSeq, operationCode, errCode, errorReturn));
968 DeleteUkNegotiateInstance(authSeq);
969 DeInitUkNegoInstanceList();
970 UkNegotiateDeinit();
971 }
972
973 /*
974 * @tc.name: JSON_OBJECT_PACK_AUTH_BASE_INFO_Test_001
975 * @tc.desc: JsonObjectPackAuthBaseInfo test
976 * @tc.type: FUNC
977 * @tc.require:
978 */
979 HWTEST_F(AuthUkManagerTest, JSON_OBJECT_PACK_AUTH_BASE_INFO_Test_001, TestSize.Level1)
980 {
981 UkNegotiateInstance instance = { 0 };
982 instance.info.isServer = true;
983 instance.info.sinkUserId = 1;
984 EXPECT_EQ(EOK, strcpy_s(instance.info.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
985 EXPECT_EQ(EOK, strcpy_s(instance.info.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
986 cJSON json;
987 (void)memset_s(&json, sizeof(cJSON), 0, sizeof(cJSON));
988 int32_t ret = JsonObjectPackAuthBaseInfo(&instance, &json);
989 EXPECT_EQ(ret, SOFTBUS_OK);
990 }
991
992 /*
993 * @tc.name: ON_REQUEST_Test_001
994 * @tc.desc: OnRequest test
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(AuthUkManagerTest, ON_REQUEST_Test_001, TestSize.Level1)
999 {
1000 uint32_t authSeq = 0;
1001 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1002 int32_t operationCode = 1;
1003 const char *reqParams = "reqParams";
1004 char *ptr = OnRequest(authSeq, operationCode, reqParams);
1005 EXPECT_EQ(ptr, nullptr);
1006 authSeq = 1;
1007 ptr = OnRequest(authSeq, operationCode, reqParams);
1008 EXPECT_EQ(ptr, nullptr);
1009 DeleteUkNegotiateInstance(authSeq);
1010 DeInitUkNegoInstanceList();
1011 UkNegotiateDeinit();
1012 }
1013
1014 /*
1015 * @tc.name: PROCESS_AUTH_HICHAIN_PARAM_Test_001
1016 * @tc.desc: ProcessAuthHichainParam test
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 */
1020 HWTEST_F(AuthUkManagerTest, PROCESS_AUTH_HICHAIN_PARAM_Test_001, TestSize.Level1)
1021 {
1022 uint32_t requestId = 1;
1023 AuthACLInfo info = { 0 };
1024 HiChainAuthMode authMode = HICHAIN_AUTH_DEVICE;
1025 int32_t ret = ProcessAuthHichainParam(requestId, &info, authMode);
1026 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
1027 }
1028
1029 /*
1030 * @tc.name: SEND_UK_NEGO_DEVICEID_Test_001
1031 * @tc.desc: SendUkNegoDeviceId test
1032 * @tc.type: FUNC
1033 * @tc.require:
1034 */
1035 HWTEST_F(AuthUkManagerTest, SEND_UK_NEGO_DEVICEID_Test_001, TestSize.Level1)
1036 {
1037 UkNegotiateInstance instance = { 0 };
1038 int32_t ret = SendUkNegoDeviceId(&instance);
1039 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1040 }
1041
1042 /*
1043 * @tc.name: PROCESS_UK_NEGO_STATE_Test_001
1044 * @tc.desc: ProcessUkNegoState test
1045 * @tc.type: FUNC
1046 * @tc.require:
1047 */
1048 HWTEST_F(AuthUkManagerTest, PROCESS_UK_NEGO_STATE_Test_001, TestSize.Level1)
1049 {
1050 AuthACLInfo info = {
1051 .isServer = false,
1052 .sinkUserId = 1,
1053 .sourceUserId = 2,
1054 .sourceTokenId = 3,
1055 .sinkTokenId = 4,
1056 };
1057 EXPECT_EQ(EOK, strcpy_s(info.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
1058 EXPECT_EQ(EOK, strcpy_s(info.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
1059 bool isGreater = false;
1060 int32_t ret = ProcessUkNegoState(&info, &isGreater);
1061 EXPECT_EQ(ret, SOFTBUS_OK);
1062 }
1063
1064 /*
1065 * @tc.name: PROCESS_UK_DEVICE_ID_Test_001
1066 * @tc.desc: ProcessUkDeviceId test
1067 * @tc.type: FUNC
1068 * @tc.require:
1069 */
1070 HWTEST_F(AuthUkManagerTest, PROCESS_UK_DEVICE_ID_Test_001, TestSize.Level1)
1071 {
1072 AuthACLInfo info;
1073 (void)memset_s(&info, sizeof(AuthACLInfo), 0, sizeof(AuthACLInfo));
1074 char *data = PackUkAclParam(&info, true);
1075 EXPECT_NE(data, nullptr);
1076 int32_t channelId = 1;
1077 uint32_t requestId = 0;
1078 uint32_t dataLen = strlen(data);
1079 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1080 int32_t ret = ProcessUkDeviceId(channelId, requestId, data, dataLen);
1081 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1082 requestId = 1;
1083 ret = ProcessUkDeviceId(channelId, requestId, data, dataLen);
1084 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1085 DeleteUkNegotiateInstance(requestId);
1086 DeInitUkNegoInstanceList();
1087 UkNegotiateDeinit();
1088 }
1089
1090 /*
1091 * @tc.name: SEND_UK_NEGO_CLOSE_ACK_EVENT_Test_001
1092 * @tc.desc: SendUkNegoCloseAckEvent test
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 HWTEST_F(AuthUkManagerTest, SEND_UK_NEGO_CLOSE_ACK_EVENT_Test_001, TestSize.Level1)
1097 {
1098 int32_t channelId = 1;
1099 uint32_t requestId = 1;
1100 int32_t ret = SendUkNegoCloseAckEvent(channelId, requestId);
1101 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1102 }
1103
1104 /*
1105 * @tc.name: PROCESS_CLOSE_ACK_DATA_Test_001
1106 * @tc.desc: ProcessCloseAckData test
1107 * @tc.type: FUNC
1108 * @tc.require:
1109 */
1110 HWTEST_F(AuthUkManagerTest, PROCESS_CLOSE_ACK_DATA_Test_001, TestSize.Level1)
1111 {
1112 const uint8_t *data = reinterpret_cast<const uint8_t *>("123456789");
1113 uint32_t dataLen = strlen("123456789");
1114 uint32_t requestId = 1;
1115 int32_t ret = ProcessCloseAckData(requestId, data, dataLen);
1116 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1117 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1118 ret = ProcessCloseAckData(requestId, data, dataLen);
1119 EXPECT_EQ(ret, SOFTBUS_OK);
1120 }
1121
1122 /*
1123 * @tc.name: SECURITY_ON_SESSION_OPENED_Test_001
1124 * @tc.desc: SecurityOnSessionOpened test
1125 * @tc.type: FUNC
1126 * @tc.require:
1127 */
1128 HWTEST_F(AuthUkManagerTest, SECURITY_ON_SESSION_OPENED_Test_001, TestSize.Level1)
1129 {
1130 int32_t channelId = 1;
1131 int32_t channelType = 1;
1132 const char *peerNetworkId = "peerNetworkId";
1133 int32_t result = SOFTBUS_INVALID_PARAM;
1134 int32_t ret = SecurityOnSessionOpened(channelId, channelType, const_cast<char *>(peerNetworkId), result);
1135 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1136 result = SOFTBUS_OK;
1137 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1138 ret = SecurityOnSessionOpened(channelId, channelType, const_cast<char *>(peerNetworkId), result);
1139 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
1140 DeleteUkNegotiateInstance(channelId);
1141 DeInitUkNegoInstanceList();
1142 UkNegotiateDeinit();
1143 }
1144
1145 /*
1146 * @tc.name: SECURITY_ON_SESSION_CLOSED_Test_001
1147 * @tc.desc: SecurityOnSessionClosed test
1148 * @tc.type: FUNC
1149 * @tc.require:
1150 */
1151 HWTEST_F(AuthUkManagerTest, SECURITY_ON_SESSION_CLOSED_Test_001, TestSize.Level1)
1152 {
1153 int32_t channelId = 1;
1154 EXPECT_NO_FATAL_FAILURE(SecurityOnSessionClosed(channelId));
1155 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1156 EXPECT_NO_FATAL_FAILURE(SecurityOnSessionClosed(channelId));
1157 DeInitUkNegoInstanceList();
1158 UkNegotiateDeinit();
1159 }
1160
1161 /*
1162 * @tc.name: SECURITY_ON_BYTES_RECEIVED_Test_001
1163 * @tc.desc: SecurityOnBytesReceived test
1164 * @tc.type: FUNC
1165 * @tc.require:
1166 */
1167 HWTEST_F(AuthUkManagerTest, SECURITY_ON_BYTES_RECEIVED_Test_001, TestSize.Level1)
1168 {
1169 const uint8_t *data = reinterpret_cast<const uint8_t *>("123456789");
1170 uint32_t len = strlen("123456789");
1171 AuthDataHead head = {
1172 .dataType = DATA_TYPE_AUTH,
1173 .module = MODULE_HICHAIN,
1174 .seq = 1,
1175 .flag = 0,
1176 .len = len,
1177 };
1178 uint32_t size = AUTH_PKT_HEAD_LEN + len;
1179 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
1180 ASSERT_TRUE(buf != nullptr);
1181 int32_t ret = PackAuthData(&head, data, buf, size);
1182 EXPECT_EQ(ret, SOFTBUS_OK);
1183 int32_t channelId = 1;
1184 uint32_t dataLen = size;
1185 EXPECT_NO_FATAL_FAILURE(SecurityOnBytesReceived(channelId, buf, dataLen));
1186 SoftBusFree(buf);
1187 }
1188
1189 /*
1190 * @tc.name: SECURITY_SET_CHANNEL_INFO_BY_REQ_ID_Test_001
1191 * @tc.desc: SecuritySetChannelInfoByReqId test
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(AuthUkManagerTest, SECURITY_SET_CHANNEL_INFO_BY_REQ_ID_Test_001, TestSize.Level1)
1196 {
1197 uint32_t requestId = 1;
1198 int32_t channelId = 1;
1199 int32_t channelType = 1;
1200 int32_t ret = SecuritySetChannelInfoByReqId(requestId, channelId, channelType);
1201 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1202 EXPECT_EQ(CreateUkNegotiateInstanceInner(), SOFTBUS_OK);
1203 ret = SecuritySetChannelInfoByReqId(requestId, channelId, channelType);
1204 EXPECT_EQ(ret, SOFTBUS_OK);
1205 DeleteUkNegotiateInstance(channelId);
1206 DeInitUkNegoInstanceList();
1207 UkNegotiateDeinit();
1208 }
1209 } // namespace OHOS
1210