1 /*
2 * Copyright (c) 2022-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 <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "lnn_huks_utils.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_error_code.h"
23
24 namespace OHOS {
25 using namespace testing::ext;
26
27 static constexpr char KEY_ALIAS[] = "dsoftbus_test_key_alias";
28 static constexpr char RANDOM_KEY[] = "b0d8bfed90d1e018c84f0a1abd4cbcc7f33481b42476719b401b1d70d3998a7c";
29 constexpr uint32_t TIME_SIZE = 3;
30
31 static struct HksBlob g_keyAlias = { 0 };
32
33 class LNNHuksUtilsTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void LNNHuksUtilsTest::SetUpTestCase()
42 {
43 g_keyAlias.size = strlen(KEY_ALIAS);
44 g_keyAlias.data = (uint8_t *)KEY_ALIAS;
45
46 EXPECT_EQ(LnnInitHuksInterface(), SOFTBUS_OK);
47 }
48
TearDownTestCase()49 void LNNHuksUtilsTest::TearDownTestCase()
50 {
51 LnnDeinitHuksInterface();
52 }
53
SetUp()54 void LNNHuksUtilsTest::SetUp() { }
55
TearDown()56 void LNNHuksUtilsTest::TearDown()
57 {
58 (void)LnnDeleteKeyByHuks(&g_keyAlias);
59 }
60
61 /*
62 * @tc.name: Generate_Key_Test_001
63 * @tc.desc: generate key test
64 * @tc.type: FUNC
65 * @tc.require: I5RHYE
66 */
67 HWTEST_F(LNNHuksUtilsTest, Generate_Key_Test_01, TestSize.Level0)
68 {
69 struct HksBlob keyAlias = { 0 };
70 keyAlias.size = strlen(KEY_ALIAS);
71 keyAlias.data = (uint8_t *)KEY_ALIAS;
72
73 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
74 }
75
76 /*
77 * @tc.name: Generate_Key_Test_002
78 * @tc.desc: generate key twice test
79 * @tc.type: FUNC
80 * @tc.require: I5RHYE
81 */
82 HWTEST_F(LNNHuksUtilsTest, Generate_Key_Test_02, TestSize.Level0)
83 {
84 struct HksBlob keyAlias = { 0 };
85 keyAlias.size = strlen(KEY_ALIAS);
86 keyAlias.data = (uint8_t *)KEY_ALIAS;
87
88 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
89 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
90 }
91
92 /*
93 * @tc.name: Generate_Random_Test_001
94 * @tc.desc: generate randowm key test
95 * @tc.type: FUNC
96 * @tc.require: I5RHYE
97 */
98 HWTEST_F(LNNHuksUtilsTest, Generate_Random_Test_01, TestSize.Level0)
99 {
100 uint8_t randomKey[LNN_HUKS_AES_COMMON_SIZE] = { 0 };
101
102 EXPECT_EQ(LnnGenerateRandomByHuks(randomKey, LNN_HUKS_AES_COMMON_SIZE), SOFTBUS_OK);
103 }
104
105 /*
106 * @tc.name: Encrypt_Data_Test_001
107 * @tc.desc: encrypt data test
108 * @tc.type: FUNC
109 * @tc.require: I5RHYE
110 */
111 HWTEST_F(LNNHuksUtilsTest, Encrypt_Data_Test_01, TestSize.Level0)
112 {
113 struct HksBlob inData = { 0 };
114 inData.size = strlen(RANDOM_KEY);
115 inData.data = (uint8_t *)RANDOM_KEY;
116
117 struct HksBlob outData = { 0 };
118 outData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
119 ASSERT_NE(outData.data, nullptr);
120
121 EXPECT_EQ(LnnGenerateKeyByHuks(&g_keyAlias), SOFTBUS_OK);
122 EXPECT_EQ(LnnEncryptDataByHuks(&g_keyAlias, &inData, &outData), SOFTBUS_OK);
123 EXPECT_NE(memcmp(inData.data, outData.data, inData.size), 0);
124 SoftBusFree(outData.data);
125 }
126
127 /*
128 * @tc.name: LNN_GENERATE_CEKEY_BY_HUKS_Test_001
129 * @tc.desc: keyAlias data is nullptr
130 * @tc.type: FUNC
131 * @tc.require: I5RHYE
132 */
133 HWTEST_F(LNNHuksUtilsTest, LNN_GENERATE_CEKEY_BY_HUKS_Test_001, TestSize.Level0)
134 {
135 struct HksBlob *keyAlias = nullptr;
136 int32_t ret = LnnGenerateCeKeyByHuks(keyAlias, true);
137 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
138 }
139
140 /*
141 * @tc.name: LNN_DELETE_CEKEY_BY_HUKS_Test_001
142 * @tc.desc: keyAlias data is nullptr
143 * @tc.type: FUNC
144 * @tc.require: I5RHYE
145 */
146 HWTEST_F(LNNHuksUtilsTest, LNN_DELETE_CEKEY_BY_HUKS_Test_001, TestSize.Level0)
147 {
148 struct HksBlob *keyAlias = nullptr;
149 int32_t ret = LnnDeleteCeKeyByHuks(keyAlias);
150 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
151 }
152
153 /*
154 * @tc.name: LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_001
155 * @tc.desc: keyAlias is nullptr
156 * @tc.type: FUNC
157 * @tc.require: I5RHYE
158 */
159 HWTEST_F(LNNHuksUtilsTest, LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_001, TestSize.Level0)
160 {
161 struct HksBlob *keyAlias = nullptr;
162 struct HksBlob inData = { 0 };
163 inData.size = TIME_SIZE;
164 inData.data = (uint8_t *)SoftBusCalloc(inData.size);
165 if (inData.data == nullptr) {
166 GTEST_LOG_(INFO) << "calloc inData data fail";
167 return;
168 }
169 struct HksBlob outData = { 0 };
170 outData.size = TIME_SIZE;
171 outData.data = (uint8_t *)SoftBusCalloc(outData.size);
172 if (outData.data == nullptr) {
173 GTEST_LOG_(INFO) << "calloc outData data fail";
174 SoftBusFree(inData.data);
175 return;
176 }
177 int32_t ret = LnnCeEncryptDataByHuks(keyAlias, &inData, &outData);
178 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
179 SoftBusFree(outData.data);
180 SoftBusFree(inData.data);
181 }
182
183 /*
184 * @tc.name: LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_002
185 * @tc.desc: inData is nullptr
186 * @tc.type: FUNC
187 * @tc.require: I5RHYE
188 */
189 HWTEST_F(LNNHuksUtilsTest, LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_002, TestSize.Level0)
190 {
191 struct HksBlob keyAlias = { 0 };
192 keyAlias.size = TIME_SIZE;
193 keyAlias.data = (uint8_t *)SoftBusCalloc(keyAlias.size);
194 if (keyAlias.data == nullptr) {
195 GTEST_LOG_(INFO) << "calloc keyAlias data fail";
196 return;
197 }
198 struct HksBlob *inData = nullptr;
199 struct HksBlob outData = { 0 };
200 outData.size = TIME_SIZE;
201 outData.data = (uint8_t *)SoftBusCalloc(outData.size);
202 if (outData.data == nullptr) {
203 GTEST_LOG_(INFO) << "calloc outData data fail";
204 SoftBusFree(keyAlias.data);
205 return;
206 }
207 int32_t ret = LnnCeEncryptDataByHuks(&keyAlias, inData, &outData);
208 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
209 SoftBusFree(outData.data);
210 SoftBusFree(keyAlias.data);
211 }
212
213 /*
214 * @tc.name: LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_003
215 * @tc.desc: outData data is nullptr
216 * @tc.type: FUNC
217 * @tc.require: I5RHYE
218 */
219 HWTEST_F(LNNHuksUtilsTest, LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_003, TestSize.Level0)
220 {
221 struct HksBlob keyAlias = { 0 };
222 keyAlias.size = TIME_SIZE;
223 keyAlias.data = (uint8_t *)SoftBusCalloc(keyAlias.size);
224 if (keyAlias.data == nullptr) {
225 GTEST_LOG_(INFO) << "calloc keyAlias data fail";
226 return;
227 }
228 struct HksBlob inData = { 0 };
229 inData.size = TIME_SIZE;
230 inData.data = (uint8_t *)SoftBusCalloc(inData.size);
231 if (inData.data == nullptr) {
232 GTEST_LOG_(INFO) << "calloc inData data fail";
233 SoftBusFree(keyAlias.data);
234 return;
235 }
236 struct HksBlob *outData = nullptr;
237 int32_t ret = LnnCeEncryptDataByHuks(&keyAlias, &inData, outData);
238 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239 SoftBusFree(inData.data);
240 SoftBusFree(keyAlias.data);
241 }
242
243 /*
244 * @tc.name: LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_004
245 * @tc.desc: inData size is INVALID_PARAM
246 * @tc.type: FUNC
247 * @tc.require: I5RHYE
248 */
249 HWTEST_F(LNNHuksUtilsTest, LNN_CE_ENCRYPT_DATA_BY_HUKS_Test_004, TestSize.Level0)
250 {
251 struct HksBlob keyAlias = { 0 };
252 keyAlias.size = TIME_SIZE;
253 keyAlias.data = (uint8_t *)SoftBusCalloc(keyAlias.size);
254 if (keyAlias.data == nullptr) {
255 GTEST_LOG_(INFO) << "calloc keyAlias data fail";
256 return;
257 }
258 struct HksBlob inData = { 0 };
259 inData.size = TIME_SIZE;
260 inData.data = (uint8_t *)SoftBusCalloc(inData.size);
261 if (inData.data == nullptr) {
262 GTEST_LOG_(INFO) << "calloc inData data fail";
263 SoftBusFree(keyAlias.data);
264 return;
265 }
266 struct HksBlob outData = { 0 };
267 outData.size = TIME_SIZE;
268 outData.data = (uint8_t *)SoftBusCalloc(outData.size);
269 if (outData.data == nullptr) {
270 GTEST_LOG_(INFO) << "calloc outData data fail";
271 SoftBusFree(inData.data);
272 SoftBusFree(keyAlias.data);
273 return;
274 }
275 inData.size = 0;
276 int32_t ret = LnnCeEncryptDataByHuks(&keyAlias, &inData, &outData);
277 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
278 SoftBusFree(outData.data);
279 SoftBusFree(inData.data);
280 SoftBusFree(keyAlias.data);
281 }
282
283 /*
284 * @tc.name: Decrypt_Data_Test_001
285 * @tc.desc: decrypt data test
286 * @tc.type: FUNC
287 * @tc.require: I5RHYE
288 */
289 HWTEST_F(LNNHuksUtilsTest, Decrypt_Data_Test_01, TestSize.Level0)
290 {
291 struct HksBlob plainData = { 0 };
292 plainData.size = strlen(RANDOM_KEY);
293 plainData.data = (uint8_t *)RANDOM_KEY;
294
295 struct HksBlob encryptData = { 0 };
296 encryptData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
297 ASSERT_NE(encryptData.data, nullptr);
298
299 struct HksBlob decryptData = { 0 };
300 decryptData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
301 if (decryptData.data == nullptr) {
302 SoftBusFree(encryptData.data);
303 return;
304 }
305 EXPECT_EQ(LnnGenerateKeyByHuks(&g_keyAlias), SOFTBUS_OK);
306 EXPECT_EQ(LnnEncryptDataByHuks(&g_keyAlias, &plainData, &encryptData), SOFTBUS_OK);
307 EXPECT_NE(memcmp(plainData.data, encryptData.data, plainData.size), 0);
308
309 EXPECT_EQ(LnnDecryptDataByHuks(&g_keyAlias, &encryptData, &decryptData), SOFTBUS_OK);
310 EXPECT_EQ(memcmp(decryptData.data, plainData.data, decryptData.size), 0);
311 SoftBusFree(encryptData.data);
312 SoftBusFree(decryptData.data);
313 }
314
315 /*
316 * @tc.name: Generate_Random_Test_02
317 * @tc.desc: generate randowm key test
318 * @tc.type: FUNC
319 * @tc.require: I5RHYE
320 */
321 HWTEST_F(LNNHuksUtilsTest, Generate_Random_Test_02, TestSize.Level0)
322 {
323 int32_t ret = LnnGenerateRandomByHuks(NULL, LNN_HUKS_AES_COMMON_SIZE);
324 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
325 }
326
327 /*
328 * @tc.name: CeDecrypt_Data_Test_01
329 * @tc.desc: decrypt data param error
330 * @tc.type: FUNC
331 * @tc.require: I5RHYE
332 */
333 HWTEST_F(LNNHuksUtilsTest, CeDecrypt_Data_Test_01, TestSize.Level0)
334 {
335 struct HksBlob keyAlias;
336 struct HksBlob inData;
337 struct HksBlob outData;
338 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
339 (void)memset_s(&inData, sizeof(HksBlob), 0, sizeof(HksBlob));
340 (void)memset_s(&outData, sizeof(HksBlob), 0, sizeof(HksBlob));
341 int32_t ret = LnnCeDecryptDataByHuks(NULL, &inData, &outData);
342 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
343 ret = LnnCeDecryptDataByHuks(&keyAlias, NULL, &outData);
344 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
345 ret = LnnCeDecryptDataByHuks(&keyAlias, &inData, NULL);
346 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
347 ret = LnnCeDecryptDataByHuks(&keyAlias, &inData, &outData);
348 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
349 }
350
351 /*
352 * @tc.name: CeDecrypt_Data_Test_02
353 * @tc.desc: decrypt data param error
354 * @tc.type: FUNC
355 * @tc.require: I5RHYE
356 */
357 HWTEST_F(LNNHuksUtilsTest, CeDecrypt_Data_Test_02, TestSize.Level0)
358 {
359 struct HksBlob keyAlias;
360 struct HksBlob inData;
361 struct HksBlob outData;
362 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
363 (void)memset_s(&inData, sizeof(HksBlob), 0, sizeof(HksBlob));
364 (void)memset_s(&outData, sizeof(HksBlob), 0, sizeof(HksBlob));
365 inData.size = LNN_HUKS_AES_COMMON_SIZE;
366 int32_t ret = LnnCeDecryptDataByHuks(&keyAlias, &inData, &outData);
367 EXPECT_EQ(ret, SOFTBUS_HUKS_INIT_FAILED);
368 }
369
370 /*
371 * @tc.name: CeEncrypt_Data_Test_01
372 * @tc.desc: encrypt data param error
373 * @tc.type: FUNC
374 * @tc.require: I5RHYE
375 */
376 HWTEST_F(LNNHuksUtilsTest, CeEncrypt_Data_Test_01, TestSize.Level0)
377 {
378 struct HksBlob keyAlias;
379 struct HksBlob inData;
380 struct HksBlob outData;
381 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
382 (void)memset_s(&inData, sizeof(HksBlob), 0, sizeof(HksBlob));
383 (void)memset_s(&outData, sizeof(HksBlob), 0, sizeof(HksBlob));
384 int32_t ret = LnnCeEncryptDataByHuks(NULL, &inData, &outData);
385 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
386 ret = LnnCeEncryptDataByHuks(&keyAlias, NULL, &outData);
387 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
388 ret = LnnCeEncryptDataByHuks(&keyAlias, &inData, NULL);
389 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
390 ret = LnnCeEncryptDataByHuks(&keyAlias, &inData, &outData);
391 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
392 }
393
394 /*
395 * @tc.name: CeEncrypt_Data_Test_02
396 * @tc.desc: encrypt data error
397 * @tc.type: FUNC
398 * @tc.require: I5RHYE
399 */
400 HWTEST_F(LNNHuksUtilsTest, CeEncrypt_Data_Test_02, TestSize.Level0)
401 {
402 struct HksBlob keyAlias;
403 struct HksBlob inData;
404 struct HksBlob outData;
405 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
406 (void)memset_s(&inData, sizeof(HksBlob), 0, sizeof(HksBlob));
407 (void)memset_s(&outData, sizeof(HksBlob), 0, sizeof(HksBlob));
408 inData.size = LNN_HUKS_AES_COMMON_SIZE;
409 int32_t ret = LnnCeEncryptDataByHuks(&keyAlias, &inData, &outData);
410 EXPECT_EQ(ret, SOFTBUS_HUKS_INIT_FAILED);
411 }
412
413 /*
414 * @tc.name: GenerateCeKey_Test_01
415 * @tc.desc: generate key param error
416 * @tc.type: FUNC
417 * @tc.require: I5RHYE
418 */
419 HWTEST_F(LNNHuksUtilsTest, GenerateCeKey_Test_01, TestSize.Level0)
420 {
421 int32_t ret = LnnGenerateCeKeyByHuks(NULL, true);
422 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
423 }
424 } // namespace OHOS
425