1 /*
2 * Copyright (c) 2023 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_errcode.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 = NULL;
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 = NULL;
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 = NULL;
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 = NULL;
206 uint32_t decryptedDataLen = 0;
207 uint8_t *decryptedData = NULL;
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 = NULL;
241 uint32_t decryptedDataLen = 0;
242 uint8_t *decryptedData = NULL;
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 SoftBusFree(encryptedData);
256 }
257
258 /*
259 * @tc.name: DataBusNativeVirtual00
260 * @tc.desc: function
261 * @tc.type: FUNC
262 * @tc.require: 1
263 */
264 HWTEST_F(AdapterDsoftbusRsaCryptoTest, DataBusNativeVirtual001, TestSize.Level0)
265 {
266 int channelId = 0;
267 int32_t ret = NotifyNearByUpdateMigrateOption(channelId);
268 EXPECT_EQ(SOFTBUS_OK, ret);
269
270 const char *peerDeviceId = NULL;
271 int routeType = 0;
272 bool isUpgrade = true;
273 ret = NotifyNearByOnMigrateEvents(peerDeviceId, routeType, isUpgrade);
274 EXPECT_EQ(SOFTBUS_OK, ret);
275
276 const char *busName = NULL;
277 ret = NotifyNearByGetBrAgingTimeoutByBusName(busName);
278 EXPECT_EQ(SOFTBUS_OK, ret);
279 }
280
ConstructKeyParamSet(struct HksParamSet ** paramSet,const struct HksParam * params,uint32_t paramCount)281 static int32_t ConstructKeyParamSet(struct HksParamSet **paramSet, const struct HksParam *params, uint32_t paramCount)
282 {
283 if (HksInitParamSet(paramSet) != HKS_SUCCESS) {
284 COMM_LOGE(COMM_TEST, "HksInitParamSet failed.");
285 return SOFTBUS_ERR;
286 }
287 if (HksAddParams(*paramSet, params, paramCount) != HKS_SUCCESS) {
288 COMM_LOGE(COMM_TEST, "HksAddParams failed.");
289 HksFreeParamSet(paramSet);
290 return SOFTBUS_ERR;
291 }
292 if (HksBuildParamSet(paramSet) != HKS_SUCCESS) {
293 COMM_LOGE(COMM_TEST, "HksBuildParamSet failed.");
294 HksFreeParamSet(paramSet);
295 return SOFTBUS_ERR;
296 }
297 return SOFTBUS_OK;
298 }
299
300 /*
301 * @tc.name: HksDecrypt001
302 * @tc.desc: parameters are Legal
303 * @tc.type: FUNC
304 * @tc.require: I5OHDE
305 */
306 HWTEST_F(AdapterDsoftbusRsaCryptoTest, HksDecrypt001, TestSize.Level0)
307 {
308 uint32_t pKeyLen = SOFTBUS_RSA_PUB_KEY_LEN;
309 uint32_t srcDataLen = 5;
310 uint8_t publicKey[pKeyLen];
311 uint8_t srcData[srcDataLen];
312 const uint8_t SOFTBUS_RSA_KEY_ALIAS[] = "DsoftbusRsaKey";
313 const struct HksBlob rsaKeyAlias = { sizeof(SOFTBUS_RSA_KEY_ALIAS), (uint8_t *)SOFTBUS_RSA_KEY_ALIAS };
314 struct HksBlob srcBlob = { srcDataLen, srcData };
315
316 int32_t ret = SoftBusGetPublicKey(publicKey, pKeyLen);
317 EXPECT_EQ(SOFTBUS_OK, ret);
318 ret = SoftBusGenerateRandomArray(srcData, srcDataLen);
319 EXPECT_EQ(SOFTBUS_OK, ret);
320
321 struct HksBlob encryptedBlob = { HKS_RSA_KEY_SIZE_4096, (uint8_t *)SoftBusCalloc(HKS_RSA_KEY_SIZE_4096) };
322 ASSERT_TRUE(encryptedBlob.data != nullptr);
323 struct HksParamSet *encryptParamSet = nullptr;
324 ret = ConstructKeyParamSet(&encryptParamSet, g_encryptParams, sizeof(g_encryptParams) / sizeof(struct HksParam));
325 EXPECT_EQ(SOFTBUS_OK, ret);
326 ret = HksEncrypt(&rsaKeyAlias, encryptParamSet, &srcBlob, &encryptedBlob);
327 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
328 HksFreeParamSet(&encryptParamSet);
329
330 struct HksBlob decryptedBlob = { HKS_RSA_KEY_SIZE_4096, (uint8_t *)SoftBusCalloc(HKS_RSA_KEY_SIZE_4096) };
331 ASSERT_TRUE(decryptedBlob.data != nullptr);
332 struct HksParamSet *decryptParamSet = nullptr;
333 ret = ConstructKeyParamSet(&decryptParamSet, g_decryptParams, sizeof(g_decryptParams) / sizeof(struct HksParam));
334 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
335 ret = HksDecrypt(&rsaKeyAlias, decryptParamSet, &encryptedBlob, &decryptedBlob);
336 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
337 ret = memcmp((const char *)decryptedBlob.data, (const char *)srcData, srcDataLen);
338 EXPECT_NE(HKS_ERROR_NULL_POINTER, ret);
339
340 HksFreeParamSet(&decryptParamSet);
341 SoftBusFree(encryptedBlob.data);
342 SoftBusFree(decryptedBlob.data);
343 }
344 } // namespace OHOS
345