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_uk_manager.h"
21 #include "auth_user_common_key.h"
22
23 namespace OHOS {
24 using namespace testing;
25 using namespace testing::ext;
26 constexpr char NODE1_UDID[] = "123456ABCDEF";
27 constexpr char NODE2_UDID[] = "123456ABCDEG";
28 constexpr char NODE1_ACCOUNT_ID[] = "123456ABCDEFACCOUNTID";
29 constexpr char NODE2_ACCOUNT_ID[] = "123456ABCDEGACCOUNTID";
30
31 class AuthUserCommonKeyTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void AuthUserCommonKeyTest::SetUpTestCase() { }
40
TearDownTestCase()41 void AuthUserCommonKeyTest::TearDownTestCase() { }
42
SetUp()43 void AuthUserCommonKeyTest::SetUp() { }
44
TearDown()45 void AuthUserCommonKeyTest::TearDown() { }
46
47 /*
48 * @tc.name: AUTH_USER_COMMON_KEY_Test_001
49 * @tc.desc: AuthUserKey test
50 * @tc.type: FUNC
51 * @tc.require:
52 */
53 HWTEST_F(AuthUserCommonKeyTest, AUTH_USER_COMMON_KEY_Test_001, TestSize.Level1)
54 {
55 AuthACLInfo aclInfo = {};
56 AuthUserKeyInfo userKeyInfo = {};
57 int32_t ret = AuthInsertUserKey(&aclInfo, &userKeyInfo, false);
58 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
59 ret = GetUserKeyInfoSameAccount(&aclInfo, &userKeyInfo);
60 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
61 ret = GetUserKeyInfoDiffAccountWithUserLevel(&aclInfo, &userKeyInfo);
62 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
63 ret = GetUserKeyInfoDiffAccount(&aclInfo, &userKeyInfo);
64 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
65 int32_t sessionKeyId = 3;
66 uint32_t ukLen = SESSION_KEY_LENGTH;
67 uint8_t uk[SESSION_KEY_LENGTH] = { 0 };
68 ret = GetUserKeyByUkId(sessionKeyId, uk, ukLen);
69 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
70 }
71
72 /*
73 * @tc.name: UTH_USER_COMMON_KEY_Test_002
74 * @tc.desc: AuthUserKeyInit test
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(AuthUserCommonKeyTest, UTH_USER_COMMON_KEY_Test_002, TestSize.Level1)
79 {
80 int32_t ret = AuthUserKeyInit();
81 EXPECT_EQ(ret, SOFTBUS_OK);
82 DeinitUserKeyList();
83 }
84
85 /*
86 * @tc.name: UTH_USER_COMMON_KEY_Test_003
87 * @tc.desc: AuthInsertUserKey test
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 HWTEST_F(AuthUserCommonKeyTest, UTH_USER_COMMON_KEY_Test_003, TestSize.Level1)
92 {
93 AuthACLInfo aclInfo = {
94 .isServer = false,
95 .sinkUserId = 1,
96 .sourceUserId = 2,
97 .sourceTokenId = 3,
98 .sinkTokenId = 4,
99 };
100 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
101 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
102 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
103 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
104 AuthUserKeyInfo userKeyInfo = {
105 .keyLen = strlen("testKey"),
106 .time = 12345,
107 .keyIndex = 1,
108 };
109 EXPECT_EQ(EOK, memcpy_s(userKeyInfo.deviceKey, SESSION_KEY_LENGTH, "testKey", strlen("testKey")));
110 int32_t ret = AuthInsertUserKey(nullptr, &userKeyInfo, false);
111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
112 ret = AuthInsertUserKey(&aclInfo, nullptr, false);
113 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
114 ret = AuthInsertUserKey(&aclInfo, &userKeyInfo, false);
115 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
116 ret = AuthUserKeyInit();
117 EXPECT_EQ(ret, SOFTBUS_OK);
118 AuthACLInfo aclInfo1 = {
119 .isServer = false,
120 .sinkUserId = 1,
121 .sourceUserId = 2,
122 .sourceTokenId = 3,
123 .sinkTokenId = 4,
124 };
125 EXPECT_EQ(EOK, strcpy_s(aclInfo1.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
126 EXPECT_EQ(EOK, strcpy_s(aclInfo1.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
127 EXPECT_EQ(EOK, strcpy_s(aclInfo1.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
128 EXPECT_EQ(EOK, strcpy_s(aclInfo1.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
129 AuthUserKeyInfo userKeyInfo1 = {
130 .keyLen = strlen("testKey1"),
131 .time = 12345,
132 .keyIndex = 2,
133 };
134 EXPECT_EQ(EOK, memcpy_s(userKeyInfo1.deviceKey, SESSION_KEY_LENGTH, "testKey1", strlen("testKey1")));
135 ret = AuthInsertUserKey(&aclInfo1, &userKeyInfo1, false);
136 EXPECT_EQ(ret, SOFTBUS_OK);
137 }
138
139 /*
140 * @tc.name: GET_USERKEY_INFO_SAME_ACCOUNT_Test_001
141 * @tc.desc: GetUserKeyInfoSameAccount test
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(AuthUserCommonKeyTest, GET_USERKEY_INFO_SAME_ACCOUNT_Test_001, TestSize.Level1)
146 {
147 AuthACLInfo aclInfo = {
148 .isServer = false,
149 .sinkUserId = 2,
150 .sourceUserId = 2,
151 .sourceTokenId = 3,
152 .sinkTokenId = 4,
153 };
154 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
155 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
156 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
157 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
158 AuthUserKeyInfo userKeyInfo1 = {
159 .keyLen = strlen("testKey1"),
160 .time = 12345,
161 .keyIndex = 1,
162 };
163 int32_t ret = AuthInsertUserKey(&aclInfo, &userKeyInfo1, false);
164 EXPECT_EQ(ret, SOFTBUS_OK);
165 AuthUserKeyInfo userKeyInfo = {};
166 ret = GetUserKeyInfoSameAccount(nullptr, &userKeyInfo);
167 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
168 aclInfo.sinkUserId = 1;
169 ret = GetUserKeyInfoSameAccount(&aclInfo, &userKeyInfo);
170 EXPECT_EQ(ret, SOFTBUS_CHANNEL_AUTH_KEY_NOT_FOUND);
171 aclInfo.sinkUserId = 2;
172 ret = GetUserKeyInfoSameAccount(&aclInfo, &userKeyInfo);
173 EXPECT_EQ(ret, SOFTBUS_OK);
174 }
175
176 /*
177 * @tc.name: GET_USERKEY_INFO_DIFF_ACCOUNT_Test_001
178 * @tc.desc: GetUserKeyInfoDiffAccount test
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(AuthUserCommonKeyTest, GET_USERKEY_INFO_DIFF_ACCOUNT_Test_001, TestSize.Level1)
183 {
184 AuthACLInfo aclInfo = {
185 .isServer = false,
186 .sinkUserId = 1,
187 .sourceUserId = 2,
188 .sourceTokenId = 3,
189 .sinkTokenId = 4,
190 };
191 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
192 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
193 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
194 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
195 AuthUserKeyInfo userKeyInfo = {};
196 int32_t ret = GetUserKeyInfoDiffAccount(nullptr, &userKeyInfo);
197 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
198 ret = GetUserKeyInfoDiffAccount(&aclInfo, &userKeyInfo);
199 EXPECT_EQ(ret, SOFTBUS_OK);
200 aclInfo.isServer = true;
201 ret = GetUserKeyInfoDiffAccount(&aclInfo, &userKeyInfo);
202 EXPECT_EQ(ret, SOFTBUS_CHANNEL_AUTH_KEY_NOT_FOUND);
203 aclInfo.isServer = false;
204 ret = GetUserKeyInfoDiffAccount(&aclInfo, &userKeyInfo);
205 EXPECT_EQ(ret, SOFTBUS_OK);
206 }
207
208 /*
209 * @tc.name: GET_USERKEY_INFO_DIFF_ACCOUNT_WITH_USER_Test_001
210 * @tc.desc: GetUserKeyInfoDiffAccountWithUserLevel test
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(AuthUserCommonKeyTest, GET_USERKEY_INFO_DIFF_ACCOUNT_WITH_USER_Test_001, TestSize.Level1)
215 {
216 AuthACLInfo aclInfo = {
217 .isServer = false,
218 .sinkUserId = 10,
219 .sourceUserId = 10,
220 .sourceTokenId = 3,
221 .sinkTokenId = 4,
222 };
223 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceUdid, UDID_BUF_LEN, NODE1_UDID));
224 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkUdid, UDID_BUF_LEN, NODE2_UDID));
225 EXPECT_EQ(EOK, strcpy_s(aclInfo.sourceAccountId, ACCOUNT_ID_BUF_LEN, NODE1_ACCOUNT_ID));
226 EXPECT_EQ(EOK, strcpy_s(aclInfo.sinkAccountId, ACCOUNT_ID_BUF_LEN, NODE2_ACCOUNT_ID));
227 AuthUserKeyInfo userKeyInfo1 = {
228 .keyLen = strlen("testKey1"),
229 .time = 12345,
230 .keyIndex = 5,
231 };
232 int32_t ret = AuthInsertUserKey(&aclInfo, &userKeyInfo1, true);
233 EXPECT_EQ(ret, SOFTBUS_OK);
234 aclInfo.isServer = true;
235 AuthUserKeyInfo userKeyInfo = {};
236 ret = GetUserKeyInfoDiffAccountWithUserLevel(nullptr, &userKeyInfo);
237 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
238 ret = GetUserKeyInfoDiffAccountWithUserLevel(&aclInfo, &userKeyInfo);
239 EXPECT_EQ(ret, SOFTBUS_CHANNEL_AUTH_KEY_NOT_FOUND);
240 aclInfo.isServer = false;
241 ret = GetUserKeyInfoDiffAccountWithUserLevel(&aclInfo, &userKeyInfo);
242 EXPECT_EQ(ret, SOFTBUS_OK);
243 }
244
245 /*
246 * @tc.name: GET_USERKEY_BY_UKID_Test_001
247 * @tc.desc: GetUserKeyByUkId test
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(AuthUserCommonKeyTest, GET_USERKEY_BY_UKID_Test_001, TestSize.Level1)
252 {
253 int32_t sessionKeyId = 3;
254 uint32_t ukLen = SESSION_KEY_LENGTH;
255 uint8_t uk[SESSION_KEY_LENGTH] = { 0 };
256 int32_t ret = GetUserKeyByUkId(sessionKeyId, uk, ukLen);
257 EXPECT_EQ(ret, SOFTBUS_CHANNEL_AUTH_KEY_NOT_FOUND);
258 sessionKeyId = 2;
259 ukLen = 1;
260 ret = GetUserKeyByUkId(sessionKeyId, uk, ukLen);
261 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
262 ukLen = strlen("testKey1");
263 ret = GetUserKeyByUkId(sessionKeyId, uk, ukLen);
264 EXPECT_EQ(ret, SOFTBUS_OK);
265 DeinitUserKeyList();
266 }
267
268 /*
269 * @tc.name: DEL_USERKEY_BY_NETWORKID_Test_001
270 * @tc.desc: DelUserKeyByNetworkId test
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(AuthUserCommonKeyTest, DEL_USERKEY_BY_NETWORKID_Test_001, TestSize.Level1)
275 {
276 EXPECT_NO_FATAL_FAILURE(DelUserKeyByNetworkId(nullptr));
277 int32_t ret = AuthUserKeyInit();
278 EXPECT_EQ(ret, SOFTBUS_OK);
279 char peerNetworkId[NETWORK_ID_BUF_LEN] = {};
280 EXPECT_NO_FATAL_FAILURE(DelUserKeyByNetworkId(peerNetworkId));
281 }
282
283 /*
284 * @tc.name: DEINIT_USERKEY_LIST_Test_001
285 * @tc.desc: DeinitUserKeyList test
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(AuthUserCommonKeyTest, DEINIT_USERKEY_LIST_Test_001, TestSize.Level1)
290 {
291 EXPECT_NO_FATAL_FAILURE(DeinitUserKeyList());
292 }
293 } // namespace OHOS