1 /*
2 * Copyright (c) 2023-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 "data_bus_native.h"
17 #include "softbus_rsa_encrypt.h"
18
19 #include <hks_api.h>
20 #include <hks_param.h>
21 #include <hks_type.h>
22 #include <securec.h>
23
24 #include "comm_log.h"
25 #include "softbus_adapter_crypto.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_error_code.h"
28 #include "gtest/gtest.h"
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 class AdapterDsoftbusRsaCryptoTest : public testing::Test {
35 protected:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
42 static struct HksParam g_encryptParams[] = {
43 { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
44 { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT },
45 { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 },
46 { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP },
47 { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
48 { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
49 { .tag = HKS_TAG_MGF_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
50 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
51 };
52 static struct HksParam g_decryptParams[] = {
53 { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA },
54 { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DECRYPT },
55 { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 },
56 { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP },
57 { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
58 { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB },
59 { .tag = HKS_TAG_MGF_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
60 { .tag = HKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = HKS_AUTH_STORAGE_LEVEL_DE },
61 };
62
SetUpTestCase(void)63 void AdapterDsoftbusRsaCryptoTest::SetUpTestCase(void) { }
TearDownTestCase(void)64 void AdapterDsoftbusRsaCryptoTest::TearDownTestCase(void) { }
SetUp()65 void AdapterDsoftbusRsaCryptoTest::SetUp() { }
TearDown()66 void AdapterDsoftbusRsaCryptoTest::TearDown() { }
67
68 /*
69 * @tc.name: SoftBusGetPublicKey001
70 * @tc.desc: parameters are Legal
71 * @tc.type: FUNC
72 * @tc.require: I5OHDE
73 */
74 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusGetPublicKey001, TestSize.Level0)
75 {
76 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
77 uint8_t publicKey[pKeyLen];
78 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
79 EXPECT_EQ(SOFTBUS_OK, ret);
80 }
81
82 /*
83 * @tc.name: SoftBusGetPublicKey002
84 * @tc.desc: parameter is nullptr
85 * @tc.type: FUNC
86 * @tc.require: I5OHDE
87 */
88 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusGetPublicKey002, TestSize.Level0)
89 {
90 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
91 int32_t ret = SoftBusGetPublicKey(nullptr, pKeyLen);
92 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
93 }
94
95 /*
96 * @tc.name: SoftBusGetPublicKey003
97 * @tc.desc: len is illegal
98 * @tc.type: FUNC
99 * @tc.require: I5OHDE
100 */
101 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusGetPublicKey003, TestSize.Level0)
102 {
103 uint8_t publicKey[SOFTBUS_RSA_PUB_KEY_LEN];
104 uint32_t pKeyLen = 0;
105 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
106 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
107 }
108
109 /*
110 * @tc.name: SoftBusRsaEncrypt001
111 * @tc.desc: parameters are Legal
112 * @tc.type: FUNC
113 * @tc.require: I5OHDE
114 */
115 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusRsaEncrypt001, TestSize.Level0)
116 {
117 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
118 uint8_t publicKey[pKeyLen];
119 uint32_t srcDataLen = 5;
120 uint8_t srcData[srcDataLen];
121 uint32_t encryptedDataLen = 0;
122 uint8_t *encryptedData = nullptr;
123
124 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
125 EXPECT_EQ(SOFTBUS_OK, ret);
126 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
127 EXPECT_EQ(SOFTBUS_OK, ret);
128 PublicKey peerPublicKey = { publicKey, pKeyLen };
129
130 ret = SoftBusRsaEncrypt(srcData, srcDataLen, &peerPublicKey, &encryptedData, &encryptedDataLen);
131 EXPECT_EQ(SOFTBUS_OK, ret);
132 SoftBusFree(encryptedData);
133 }
134
135 /*
136 * @tc.name: SoftBusRsaEncrypt002
137 * @tc.desc: parameter is nullptr
138 * @tc.type: FUNC
139 * @tc.require: I5OHDE
140 */
141 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusRsaEncrypt002, TestSize.Level0)
142 {
143 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
144 uint8_t publicKey[pKeyLen];
145 uint32_t srcDataLen = 5;
146 uint8_t srcData[srcDataLen];
147 uint32_t encryptedDataLen = 0;
148 uint8_t *encryptedData = nullptr;
149
150 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
151 EXPECT_EQ(SOFTBUS_OK, ret);
152 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
153 EXPECT_EQ(SOFTBUS_OK, ret);
154 PublicKey peerPublicKey = { publicKey, pKeyLen };
155
156 ret = SoftBusRsaEncrypt(nullptr, srcDataLen, &peerPublicKey, &encryptedData, &encryptedDataLen);
157 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
158 ret = SoftBusRsaEncrypt(srcData, srcDataLen, nullptr, &encryptedData, &encryptedDataLen);
159 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
160 ret = SoftBusRsaEncrypt(srcData, srcDataLen, &peerPublicKey, nullptr, &encryptedDataLen);
161 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
162 ret = SoftBusRsaEncrypt(srcData, srcDataLen, &peerPublicKey, &encryptedData, nullptr);
163 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
164 }
165
166 /*
167 * @tc.name: SoftBusRsaEncrypt003
168 * @tc.desc: srcDataLen is illegal
169 * @tc.type: FUNC
170 * @tc.require: I5OHDE
171 */
172 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusRsaEncrypt003, TestSize.Level0)
173 {
174 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
175 uint8_t publicKey[pKeyLen];
176 uint32_t inDataLen = 0;
177 uint32_t srcDataLen = 5;
178 uint8_t srcData[srcDataLen];
179 uint32_t encryptedDataLen = 0;
180 uint8_t *encryptedData = nullptr;
181
182 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
183 EXPECT_EQ(SOFTBUS_OK, ret);
184 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
185 EXPECT_EQ(SOFTBUS_OK, ret);
186 PublicKey peerPublicKey = { publicKey, pKeyLen };
187
188 ret = SoftBusRsaEncrypt(srcData, inDataLen, &peerPublicKey, &encryptedData, &encryptedDataLen);
189 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
190 }
191
192 /*
193 * @tc.name: SoftBusRsaDecrypt002
194 * @tc.desc: parameter is nullptr
195 * @tc.type: FUNC
196 * @tc.require: I5OHDE
197 */
198 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusRsaDecrypt002, TestSize.Level0)
199 {
200 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
201 uint8_t publicKey[pKeyLen];
202 uint32_t srcDataLen = 5;
203 uint8_t srcData[srcDataLen];
204 uint32_t encryptedDataLen = 0;
205 uint8_t *encryptedData = nullptr;
206 uint32_t decryptedDataLen = 0;
207 uint8_t *decryptedData = nullptr;
208
209 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
210 EXPECT_EQ(SOFTBUS_OK, ret);
211 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
212 EXPECT_EQ(SOFTBUS_OK, ret);
213 PublicKey peerPublicKey = { publicKey, pKeyLen };
214 ret = SoftBusRsaEncrypt(srcData, srcDataLen, &peerPublicKey, &encryptedData, &encryptedDataLen);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216
217 ret = SoftBusRsaDecrypt(nullptr, encryptedDataLen, &decryptedData, &decryptedDataLen);
218 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
219 ret = SoftBusRsaDecrypt(encryptedData, encryptedDataLen, nullptr, &decryptedDataLen);
220 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
221 ret = SoftBusRsaDecrypt(encryptedData, encryptedDataLen, &decryptedData, nullptr);
222 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
223
224 SoftBusFree(encryptedData);
225 }
226
227 /*
228 * @tc.name: SoftBusRsaDecrypt003
229 * @tc.desc: inDatalen is illegal
230 * @tc.type: FUNC
231 * @tc.require: I5OHDE
232 */
233 HWTEST_F(AdapterDsoftbusRsaCryptoTest, SoftBusRsaDecrypt003, TestSize.Level0)
234 {
235 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
236 uint8_t publicKey[pKeyLen];
237 uint32_t srcDataLen = 5;
238 uint8_t srcData[srcDataLen];
239 uint32_t encryptedDataLen = 0;
240 uint8_t *encryptedData = nullptr;
241 uint32_t decryptedDataLen = 0;
242 uint8_t *decryptedData = nullptr;
243 uint32_t srcDataLen1 = 0;
244
245 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
246 EXPECT_EQ(SOFTBUS_OK, ret);
247 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
248 EXPECT_EQ(SOFTBUS_OK, ret);
249 PublicKey peerPublicKey = { publicKey, pKeyLen };
250 ret = SoftBusRsaEncrypt(srcData, srcDataLen, &peerPublicKey, &encryptedData, &encryptedDataLen);
251 EXPECT_EQ(SOFTBUS_OK, ret);
252
253 ret = SoftBusRsaDecrypt(encryptedData, srcDataLen1, &decryptedData, &decryptedDataLen);
254 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
255 ret = SoftBusRsaDecrypt(encryptedData, encryptedDataLen, &decryptedData, &decryptedDataLen);
256 EXPECT_EQ(SOFTBUS_OK, ret);
257 SoftBusFree(decryptedData);
258 SoftBusFree(encryptedData);
259 }
260
261 /*
262 * @tc.name: DataBusNativeVirtual00
263 * @tc.desc: function
264 * @tc.type: FUNC
265 * @tc.require: 1
266 */
267 HWTEST_F(AdapterDsoftbusRsaCryptoTest, DataBusNativeVirtual001, TestSize.Level0)
268 {
269 int32_t channelId = 0;
270 int32_t ret = NotifyNearByUpdateMigrateOption(channelId);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272
273 const char *peerDeviceId = nullptr;
274 int32_t routeType = 0;
275 bool isUpgrade = true;
276 ret = NotifyNearByOnMigrateEvents(peerDeviceId, routeType, isUpgrade);
277 EXPECT_EQ(SOFTBUS_OK, ret);
278
279 const char *busName = nullptr;
280 ret = NotifyNearByGetBrAgingTimeoutByBusName(busName);
281 EXPECT_EQ(SOFTBUS_OK, ret);
282 }
283
ConstructKeyParamSet(struct HksParamSet ** paramSet,const struct HksParam * params,uint32_t paramCount)284 static int32_t ConstructKeyParamSet(struct HksParamSet **paramSet, const struct HksParam *params, uint32_t paramCount)
285 {
286 if (HksInitParamSet(paramSet) != HKS_SUCCESS) {
287 COMM_LOGE(COMM_TEST, "HksInitParamSet failed.");
288 return SOFTBUS_HUKS_ERR;
289 }
290 if (HksAddParams(*paramSet, params, paramCount) != HKS_SUCCESS) {
291 COMM_LOGE(COMM_TEST, "HksAddParams failed.");
292 HksFreeParamSet(paramSet);
293 return SOFTBUS_HUKS_ERR;
294 }
295 if (HksBuildParamSet(paramSet) != HKS_SUCCESS) {
296 COMM_LOGE(COMM_TEST, "HksBuildParamSet failed.");
297 HksFreeParamSet(paramSet);
298 return SOFTBUS_HUKS_ERR;
299 }
300 return SOFTBUS_OK;
301 }
302
303 /*
304 * @tc.name: HksDecrypt001
305 * @tc.desc: parameters are Legal
306 * @tc.type: FUNC
307 * @tc.require: I5OHDE
308 */
309 HWTEST_F(AdapterDsoftbusRsaCryptoTest, HksDecrypt001, TestSize.Level0)
310 {
311 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
312 uint32_t srcDataLen = 5;
313 uint8_t publicKey[pKeyLen];
314 uint8_t srcData[srcDataLen];
315 const uint8_t SOFTBUS_RSA_KEY_ALIAS[] = "DsoftbusRsaKey";
316 const struct HksBlob rsaKeyAlias = { sizeof(SOFTBUS_RSA_KEY_ALIAS), (uint8_t *)SOFTBUS_RSA_KEY_ALIAS };
317 struct HksBlob srcBlob = { srcDataLen, srcData };
318
319 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
320 EXPECT_EQ(SOFTBUS_OK, ret);
321 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
322 EXPECT_EQ(SOFTBUS_OK, ret);
323
324 struct HksBlob encryptedBlob = { HKS_RSA_KEY_SIZE_4096, (uint8_t *)SoftBusCalloc(HKS_RSA_KEY_SIZE_4096) };
325 ASSERT_TRUE(encryptedBlob.data != nullptr);
326 struct HksParamSet *encryptParamSet = nullptr;
327 ret = ConstructKeyParamSet(&encryptParamSet, g_encryptParams, sizeof(g_encryptParams) / sizeof(struct HksParam));
328 EXPECT_EQ(SOFTBUS_OK, ret);
329 ret = HksEncrypt(&rsaKeyAlias, encryptParamSet, &srcBlob, &encryptedBlob);
330 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
331 HksFreeParamSet(&encryptParamSet);
332
333 struct HksBlob decryptedBlob = { HKS_RSA_KEY_SIZE_4096, (uint8_t *)SoftBusCalloc(HKS_RSA_KEY_SIZE_4096) };
334 ASSERT_TRUE(decryptedBlob.data != nullptr);
335 struct HksParamSet *decryptParamSet = nullptr;
336 ret = ConstructKeyParamSet(&decryptParamSet, g_decryptParams, sizeof(g_decryptParams) / sizeof(struct HksParam));
337 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
338 ret = HksDecrypt(&rsaKeyAlias, decryptParamSet, &encryptedBlob, &decryptedBlob);
339 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
340 ret = memcmp((const char *)decryptedBlob.data, (const char *)srcData, srcDataLen);
341 EXPECT_EQ(0, ret);
342
343 HksFreeParamSet(&decryptParamSet);
344 SoftBusFree(encryptedBlob.data);
345 SoftBusFree(decryptedBlob.data);
346 }
347 } // namespace OHOS
348