1 /*
2 * Copyright (c) 2022 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_errcode.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
30 static struct HksBlob g_keyAlias = {0};
31
32 class LnnHuksUtilsTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void LnnHuksUtilsTest::SetUpTestCase()
41 {
42 g_keyAlias.size = strlen(KEY_ALIAS);
43 g_keyAlias.data = (uint8_t *)KEY_ALIAS;
44
45 EXPECT_EQ(LnnInitHuksInterface(), SOFTBUS_OK);
46 }
47
TearDownTestCase()48 void LnnHuksUtilsTest::TearDownTestCase()
49 {
50 LnnDeinitHuksInterface();
51 }
52
SetUp()53 void LnnHuksUtilsTest::SetUp()
54 {
55 }
56
TearDown()57 void LnnHuksUtilsTest::TearDown()
58 {
59 (void)LnnDeleteKeyByHuks(&g_keyAlias);
60 }
61
62 /*
63 * @tc.name: Generate_Key_Test_001
64 * @tc.desc: generate key test
65 * @tc.type: FUNC
66 * @tc.require: I5RHYE
67 */
68 HWTEST_F(LnnHuksUtilsTest, Generate_Key_Test_01, TestSize.Level0)
69 {
70 struct HksBlob keyAlias = {0};
71 keyAlias.size = strlen(KEY_ALIAS);
72 keyAlias.data = (uint8_t *)KEY_ALIAS;
73
74 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
75 }
76
77 /*
78 * @tc.name: Generate_Key_Test_002
79 * @tc.desc: generate key twice test
80 * @tc.type: FUNC
81 * @tc.require: I5RHYE
82 */
83 HWTEST_F(LnnHuksUtilsTest, Generate_Key_Test_02, TestSize.Level0)
84 {
85 struct HksBlob keyAlias = {0};
86 keyAlias.size = strlen(KEY_ALIAS);
87 keyAlias.data = (uint8_t *)KEY_ALIAS;
88
89 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
90 EXPECT_EQ(LnnGenerateKeyByHuks(&keyAlias), SOFTBUS_OK);
91 }
92
93 /*
94 * @tc.name: Generate_Random_Test_001
95 * @tc.desc: generate randowm key test
96 * @tc.type: FUNC
97 * @tc.require: I5RHYE
98 */
99 HWTEST_F(LnnHuksUtilsTest, Generate_Random_Test_01, TestSize.Level0)
100 {
101 uint8_t randomKey[LNN_HUKS_AES_COMMON_SIZE] = {0};
102
103 EXPECT_EQ(LnnGenerateRandomByHuks(randomKey, LNN_HUKS_AES_COMMON_SIZE), SOFTBUS_OK);
104 }
105
106 /*
107 * @tc.name: Encrypt_Data_Test_001
108 * @tc.desc: encrypt data test
109 * @tc.type: FUNC
110 * @tc.require: I5RHYE
111 */
112 HWTEST_F(LnnHuksUtilsTest, Encrypt_Data_Test_01, TestSize.Level0)
113 {
114 struct HksBlob inData = {0};
115 inData.size = strlen(RANDOM_KEY);
116 inData.data = (uint8_t *)RANDOM_KEY;
117
118 struct HksBlob outData = {0};
119 outData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
120 ASSERT_NE(outData.data, nullptr);
121
122 EXPECT_EQ(LnnGenerateKeyByHuks(&g_keyAlias), SOFTBUS_OK);
123 EXPECT_EQ(LnnEncryptDataByHuks(&g_keyAlias, &inData, &outData), SOFTBUS_OK);
124 EXPECT_NE(memcmp(inData.data, outData.data, inData.size), 0);
125 SoftBusFree(outData.data);
126 }
127
128 /*
129 * @tc.name: Decrypt_Data_Test_001
130 * @tc.desc: decrypt data test
131 * @tc.type: FUNC
132 * @tc.require: I5RHYE
133 */
134 HWTEST_F(LnnHuksUtilsTest, Decrypt_Data_Test_01, TestSize.Level0)
135 {
136 struct HksBlob plainData = {0};
137 plainData.size = strlen(RANDOM_KEY);
138 plainData.data = (uint8_t *)RANDOM_KEY;
139
140 struct HksBlob encryptData = {0};
141 encryptData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
142 ASSERT_NE(encryptData.data, nullptr);
143
144 struct HksBlob decryptData = {0};
145 decryptData.data = (uint8_t *)SoftBusCalloc(LNN_HUKS_AES_COMMON_SIZE);
146 ASSERT_NE(decryptData.data, nullptr);
147
148 EXPECT_EQ(LnnGenerateKeyByHuks(&g_keyAlias), SOFTBUS_OK);
149 EXPECT_EQ(LnnEncryptDataByHuks(&g_keyAlias, &plainData, &encryptData), SOFTBUS_OK);
150 EXPECT_NE(memcmp(plainData.data, encryptData.data, plainData.size), 0);
151
152 EXPECT_EQ(LnnDecryptDataByHuks(&g_keyAlias, &encryptData, &decryptData), SOFTBUS_OK);
153 EXPECT_EQ(memcmp(decryptData.data, plainData.data, decryptData.size), 0);
154 SoftBusFree(encryptData.data);
155 SoftBusFree(decryptData.data);
156 }
157 } // namespace OHOS
158