1 /*
2 * Copyright (C) 2024 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 <gtest/gtest.h>
17 #include "securec.h"
18 #include "asy_key_generator.h"
19 #include "cipher.h"
20 #include "cipher_rsa_openssl.h"
21 #include "detailed_rsa_key_params.h"
22 #include "key_pair.h"
23 #include "memory.h"
24 #include "cstring"
25 #include "openssl_common.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace {
31 class CryptoRsaCipherSubTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void CryptoRsaCipherSubTest::SetUpTestCase() {}
TearDownTestCase()40 void CryptoRsaCipherSubTest::TearDownTestCase() {}
SetUp()41 void CryptoRsaCipherSubTest::SetUp() {}
TearDown()42 void CryptoRsaCipherSubTest::TearDown() {}
43
44 namespace {
45 constexpr uint32_t RSA_2048_N_BYTE_SIZE = 256;
46 constexpr uint32_t RSA_2048_D_BYTE_SIZE = 256;
47 constexpr uint32_t RSA_2048_E_BYTE_SIZE = 3;
48
49 constexpr unsigned char CORRECT_N[] =
50 "\x92\x60\xd0\x75\x0a\xe1\x17\xee\xe5\x5c\x3f\x3d\xea\xba\x74\x91"
51 "\x75\x21\xa2\x62\xee\x76\x00\x7c\xdf\x8a\x56\x75\x5a\xd7\x3a\x15"
52 "\x98\xa1\x40\x84\x10\xa0\x14\x34\xc3\xf5\xbc\x54\xa8\x8b\x57\xfa"
53 "\x19\xfc\x43\x28\xda\xea\x07\x50\xa4\xc4\x4e\x88\xcf\xf3\xb2\x38"
54 "\x26\x21\xb8\x0f\x67\x04\x64\x43\x3e\x43\x36\xe6\xd0\x03\xe8\xcd"
55 "\x65\xbf\xf2\x11\xda\x14\x4b\x88\x29\x1c\x22\x59\xa0\x0a\x72\xb7"
56 "\x11\xc1\x16\xef\x76\x86\xe8\xfe\xe3\x4e\x4d\x93\x3c\x86\x81\x87"
57 "\xbd\xc2\x6f\x7b\xe0\x71\x49\x3c\x86\xf7\xa5\x94\x1c\x35\x10\x80"
58 "\x6a\xd6\x7b\x0f\x94\xd8\x8f\x5c\xf5\xc0\x2a\x09\x28\x21\xd8\x62"
59 "\x6e\x89\x32\xb6\x5c\x5b\xd8\xc9\x20\x49\xc2\x10\x93\x2b\x7a\xfa"
60 "\x7a\xc5\x9c\x0e\x88\x6a\xe5\xc1\xed\xb0\x0d\x8c\xe2\xc5\x76\x33"
61 "\xdb\x26\xbd\x66\x39\xbf\xf7\x3c\xee\x82\xbe\x92\x75\xc4\x02\xb4"
62 "\xcf\x2a\x43\x88\xda\x8c\xf8\xc6\x4e\xef\xe1\xc5\xa0\xf5\xab\x80"
63 "\x57\xc3\x9f\xa5\xc0\x58\x9c\x3e\x25\x3f\x09\x60\x33\x23\x00\xf9"
64 "\x4b\xea\x44\x87\x7b\x58\x8e\x1e\xdb\xde\x97\xcf\x23\x60\x72\x7a"
65 "\x09\xb7\x75\x26\x2d\x7e\xe5\x52\xb3\x31\x9b\x92\x66\xf0\x5a\x25";
66
67 constexpr unsigned char CORRECT_E[] = "\x01\x00\x01";
68
69 constexpr unsigned char CORRECT_D[] =
70 "\x6a\x7d\xf2\xca\x63\xea\xd4\xdd\xa1\x91\xd6\x14\xb6\xb3\x85\xe0"
71 "\xd9\x05\x6a\x3d\x6d\x5c\xfe\x07\xdb\x1d\xaa\xbe\xe0\x22\xdb\x08"
72 "\x21\x2d\x97\x61\x3d\x33\x28\xe0\x26\x7c\x9d\xd2\x3d\x78\x7a\xbd"
73 "\xe2\xaf\xcb\x30\x6a\xeb\x7d\xfc\xe6\x92\x46\xcc\x73\xf5\xc8\x7f"
74 "\xdf\x06\x03\x01\x79\xa2\x11\x4b\x76\x7d\xb1\xf0\x83\xff\x84\x1c"
75 "\x02\x5d\x7d\xc0\x0c\xd8\x24\x35\xb9\xa9\x0f\x69\x53\x69\xe9\x4d"
76 "\xf2\x3d\x2c\xe4\x58\xbc\x3b\x32\x83\xad\x8b\xba\x2b\x8f\xa1\xba"
77 "\x62\xe2\xdc\xe9\xac\xcf\xf3\x79\x9a\xae\x7c\x84\x00\x16\xf3\xba"
78 "\x8e\x00\x48\xc0\xb6\xcc\x43\x39\xaf\x71\x61\x00\x3a\x5b\xeb\x86"
79 "\x4a\x01\x64\xb2\xc1\xc9\x23\x7b\x64\xbc\x87\x55\x69\x94\x35\x1b"
80 "\x27\x50\x6c\x33\xd4\xbc\xdf\xce\x0f\x9c\x49\x1a\x7d\x6b\x06\x28"
81 "\xc7\xc8\x52\xbe\x4f\x0a\x9c\x31\x32\xb2\xed\x3a\x2c\x88\x81\xe9"
82 "\xaa\xb0\x7e\x20\xe1\x7d\xeb\x07\x46\x91\xbe\x67\x77\x76\xa7\x8b"
83 "\x5c\x50\x2e\x05\xd9\xbd\xde\x72\x12\x6b\x37\x38\x69\x5e\x2d\xd1"
84 "\xa0\xa9\x8a\x14\x24\x7c\x65\xd8\xa7\xee\x79\x43\x2a\x09\x2c\xb0"
85 "\x72\x1a\x12\xdf\x79\x8e\x44\xf7\xcf\xce\x0c\x49\x81\x47\xa9\xb1";
86
87 const char *g_rsaAlgName = "RSA";
88
GetMockClass(void)89 static const char *GetMockClass(void)
90 {
91 return "Mock";
92 }
93
94 static HcfObjectBase g_obj = {
95 .getClass = GetMockClass,
96 .destroy = nullptr
97 };
98 }
99
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)100 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
101 {
102 for (size_t i = 0; i < destLen; i++) {
103 dest[i] = str[i];
104 }
105 return;
106 }
107
EndianSwap(unsigned char * pData,int startIndex,int length)108 static void EndianSwap(unsigned char *pData, int startIndex, int length)
109 {
110 int cnt = length / 2;
111 int start = startIndex;
112 int end = startIndex + length - 1;
113 unsigned char tmp;
114 for (int i = 0; i < cnt; i++) {
115 tmp = pData[start + i];
116 pData[start + i] = pData[end - i];
117 pData[end - i] = tmp;
118 }
119 }
120
121 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)122 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
123 {
124 RemoveLastChar(CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
125 if (!IsBigEndian()) {
126 // the device is not big endian
127 EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
128 }
129 returnSpec->n.data = dataN;
130 returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
131 returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
132 returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
133 return;
134 }
135
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)136 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
137 HcfRsaKeyPairParamsSpec *returnPairSpec)
138 {
139 HcfRsaCommParamsSpec rsaCommSpec = {};
140 GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
141 RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
142 RemoveLastChar(CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
143 if (!IsBigEndian()) {
144 // the device is not big endian
145 EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
146 EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
147 }
148 returnPairSpec->pk.data = dataE;
149 returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
150 returnPairSpec->sk.data = dataD;
151 returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
152 returnPairSpec->base = rsaCommSpec;
153 returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
154 }
155
156 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest009, TestSize.Level0)
157 {
158 uint8_t plan[] = "this is rsa cipher test!\0";
159 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
160 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
161 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
162 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
163 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
164
165 HcfAsyKeyGeneratorBySpec *generator = nullptr;
166 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
167 EXPECT_EQ(res, HCF_SUCCESS);
168 HcfKeyPair *keyPair = nullptr;
169 res = generator->generateKeyPair(generator, &keyPair);
170 EXPECT_EQ(res, HCF_SUCCESS);
171 EXPECT_NE(keyPair, nullptr);
172
173 HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
174 HcfBlob encoutput = {.data = nullptr, .len = 0};
175 HcfCipher *cipher = nullptr;
176 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
177 EXPECT_EQ(res, HCF_SUCCESS);
178 res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
179 EXPECT_EQ(res, HCF_SUCCESS);
180
181 uint8_t pSourceData[] = "123456\0";
182 HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
183 // enum error
184 res = cipher->setCipherSpecUint8Array(reinterpret_cast<HcfCipher *>(&g_obj),
185 OAEP_MD_NAME_STR, pSource);
186 EXPECT_NE(res, HCF_SUCCESS);
187 res = cipher->doFinal(cipher, &input, &encoutput);
188 EXPECT_EQ(res, HCF_SUCCESS);
189 HcfObjDestroy(cipher);
190
191 // free
192 HcfFree(encoutput.data);
193
194 HcfObjDestroy(keyPair);
195 HcfObjDestroy(generator);
196 }
197
198 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest013, TestSize.Level0)
199 {
200 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
201 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
202 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
203 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
204 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
205
206 HcfAsyKeyGeneratorBySpec *generator = nullptr;
207 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
208 EXPECT_EQ(res, HCF_SUCCESS);
209 HcfKeyPair *keyPair = nullptr;
210 res = generator->generateKeyPair(generator, &keyPair);
211 EXPECT_EQ(res, HCF_SUCCESS);
212 EXPECT_NE(keyPair, nullptr);
213
214 HcfCipher *cipher = nullptr;
215 char *ret = nullptr;
216 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
217 EXPECT_EQ(res, HCF_SUCCESS);
218 res = cipher->getCipherSpecString(reinterpret_cast<HcfCipher *>(&g_obj), OAEP_MD_NAME_STR, &ret);
219 EXPECT_NE(res, HCF_SUCCESS);
220 EXPECT_EQ(ret, nullptr);
221
222 HcfObjDestroy(cipher);
223
224 HcfObjDestroy(keyPair);
225 HcfObjDestroy(generator);
226 }
227
228 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest017, TestSize.Level0)
229 {
230 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
231 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
232 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
233 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
234 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
235
236 HcfAsyKeyGeneratorBySpec *generator = nullptr;
237 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
238 EXPECT_EQ(res, HCF_SUCCESS);
239 HcfKeyPair *keyPair = nullptr;
240 res = generator->generateKeyPair(generator, &keyPair);
241 EXPECT_EQ(res, HCF_SUCCESS);
242 EXPECT_NE(keyPair, nullptr);
243
244 HcfCipher *cipher = nullptr;
245 HcfBlob retBlob = { .data = nullptr, .len = 0 };
246 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
247 EXPECT_EQ(res, HCF_SUCCESS);
248 res = cipher->getCipherSpecUint8Array(reinterpret_cast<HcfCipher *>(&g_obj), OAEP_MGF1_PSRC_UINT8ARR, &retBlob);
249 EXPECT_NE(res, HCF_SUCCESS);
250 EXPECT_EQ(retBlob.data, nullptr);
251
252 HcfObjDestroy(cipher);
253
254 HcfObjDestroy(keyPair);
255 HcfObjDestroy(generator);
256 }
257
258 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest018, TestSize.Level0)
259 {
260 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
261 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
262 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
263 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
264 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
265
266 HcfAsyKeyGeneratorBySpec *generator = nullptr;
267 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
268 EXPECT_EQ(res, HCF_SUCCESS);
269 HcfKeyPair *keyPair = nullptr;
270 res = generator->generateKeyPair(generator, &keyPair);
271 EXPECT_EQ(res, HCF_SUCCESS);
272 EXPECT_NE(keyPair, nullptr);
273
274 HcfCipher *cipher = nullptr;
275 HcfBlob retBlob = { .data = nullptr, .len = 0 };
276 res = HcfCipherCreate("RSA|PKCS1|SHA256", &cipher);
277 EXPECT_EQ(res, HCF_SUCCESS);
278 res = cipher->getCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, &retBlob);
279 EXPECT_NE(res, HCF_SUCCESS);
280 EXPECT_EQ(retBlob.data, nullptr);
281
282 HcfObjDestroy(cipher);
283
284 HcfObjDestroy(keyPair);
285 HcfObjDestroy(generator);
286 }
287
288 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest019, TestSize.Level0)
289 {
290 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
291 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
292 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
293 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
294 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
295
296 HcfAsyKeyGeneratorBySpec *generator = nullptr;
297 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
298 EXPECT_EQ(res, HCF_SUCCESS);
299 HcfKeyPair *keyPair = nullptr;
300 res = generator->generateKeyPair(generator, &keyPair);
301 EXPECT_EQ(res, HCF_SUCCESS);
302 EXPECT_NE(keyPair, nullptr);
303
304 HcfCipher *cipher = nullptr;
305 HcfBlob retBlob = { .data = nullptr, .len = 0 };
306 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
307 EXPECT_EQ(res, HCF_SUCCESS);
308 res = cipher->setCipherSpecUint8Array(nullptr, OAEP_MD_NAME_STR, retBlob);
309 EXPECT_NE(res, HCF_SUCCESS);
310
311 HcfObjDestroy(cipher);
312
313 HcfObjDestroy(keyPair);
314 HcfObjDestroy(generator);
315 }
316
317 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest020, TestSize.Level0)
318 {
319 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
320 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
321 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
322 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
323 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
324
325 HcfAsyKeyGeneratorBySpec *generator = nullptr;
326 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
327 EXPECT_EQ(res, HCF_SUCCESS);
328 HcfKeyPair *keyPair = nullptr;
329 res = generator->generateKeyPair(generator, &keyPair);
330 EXPECT_EQ(res, HCF_SUCCESS);
331 EXPECT_NE(keyPair, nullptr);
332
333 HcfCipher *cipher = nullptr;
334 HcfBlob retBlob = { .data = nullptr, .len = 0 };
335 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
336 EXPECT_EQ(res, HCF_SUCCESS);
337 res = cipher->setCipherSpecUint8Array(cipher, OAEP_MD_NAME_STR, retBlob);
338 EXPECT_NE(res, HCF_SUCCESS);
339
340 HcfObjDestroy(cipher);
341
342 HcfObjDestroy(keyPair);
343 HcfObjDestroy(generator);
344 }
345
346 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest021, TestSize.Level0)
347 {
348 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
349 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
350 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
351 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
352 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
353
354 HcfAsyKeyGeneratorBySpec *generator = nullptr;
355 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
356 EXPECT_EQ(res, HCF_SUCCESS);
357 HcfKeyPair *keyPair = nullptr;
358 res = generator->generateKeyPair(generator, &keyPair);
359 EXPECT_EQ(res, HCF_SUCCESS);
360 EXPECT_NE(keyPair, nullptr);
361
362 HcfCipher *cipher = nullptr;
363 HcfBlob retBlob = { .data = nullptr, .len = 0 };
364 res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
365 EXPECT_EQ(res, HCF_SUCCESS);
366 res = cipher->setCipherSpecUint8Array(reinterpret_cast<HcfCipher *>(&g_obj), OAEP_MGF1_PSRC_UINT8ARR, retBlob);
367 EXPECT_NE(res, HCF_SUCCESS);
368
369 HcfObjDestroy(cipher);
370
371 HcfObjDestroy(keyPair);
372 HcfObjDestroy(generator);
373 }
374
375 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest022, TestSize.Level0)
376 {
377 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
378 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
379 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
380 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
381 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
382
383 HcfAsyKeyGeneratorBySpec *generator = nullptr;
384 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
385 EXPECT_EQ(res, HCF_SUCCESS);
386 HcfKeyPair *keyPair = nullptr;
387 res = generator->generateKeyPair(generator, &keyPair);
388 EXPECT_EQ(res, HCF_SUCCESS);
389 EXPECT_NE(keyPair, nullptr);
390
391 HcfCipher *cipher = nullptr;
392 HcfBlob retBlob = { .data = nullptr, .len = 0 };
393 res = HcfCipherCreate("RSA|PKCS1|SHA256", &cipher);
394 EXPECT_EQ(res, HCF_SUCCESS);
395 res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, retBlob);
396 EXPECT_NE(res, HCF_SUCCESS);
397
398 HcfObjDestroy(cipher);
399
400 HcfObjDestroy(keyPair);
401 HcfObjDestroy(generator);
402 }
403
404 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest023, TestSize.Level0)
405 {
406 HcfCipher *cipher = nullptr;
407 HcfResult res = HcfCipherCreate("RSA|PKCS1|SHA256", &cipher);
408 EXPECT_EQ(res, HCF_SUCCESS);
409 res = cipher->update(cipher, nullptr, nullptr);
410 EXPECT_NE(res, HCF_SUCCESS);
411
412 HcfObjDestroy(cipher);
413 }
414
415 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest024, TestSize.Level0)
416 {
417 HcfCipher *cipher = nullptr;
418 HcfResult res = HcfCipherCreate("RSA|PKCS1|SHA256", &cipher);
419 EXPECT_EQ(res, HCF_SUCCESS);
420 HcfBlob tmp = { .data = nullptr, .len = 0 };
421 res = cipher->update(cipher, &tmp, nullptr);
422 EXPECT_NE(res, HCF_SUCCESS);
423
424 HcfObjDestroy(cipher);
425 }
426
427 // spi test
428 // create
429 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest025, TestSize.Level0)
430 {
431 HcfCipherGeneratorSpi *spiObj = nullptr;
432 HcfResult res = HcfCipherRsaCipherSpiCreate(nullptr, &spiObj);
433
434 ASSERT_NE(res, HCF_SUCCESS);
435 ASSERT_EQ(spiObj, nullptr);
436 }
437
438 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest026, TestSize.Level0)
439 {
440 HcfCipherGeneratorSpi *spiObj = nullptr;
441 HcfResult res = HcfCipherRsaCipherSpiCreate(nullptr, nullptr);
442
443 ASSERT_NE(res, HCF_SUCCESS);
444 ASSERT_EQ(spiObj, nullptr);
445 }
446
447 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest027, TestSize.Level0)
448 {
449 CipherAttr params = {
450 .algo = HCF_ALG_ECC,
451 .mode = HCF_ALG_MODE_NONE,
452 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
453 .md = HCF_OPENSSL_DIGEST_SHA256,
454 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
455 };
456 HcfCipherGeneratorSpi *spiObj = nullptr;
457 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
458
459 ASSERT_NE(res, HCF_SUCCESS);
460 ASSERT_EQ(spiObj, nullptr);
461 }
462
463 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest028, TestSize.Level0)
464 {
465 CipherAttr params = {
466 .algo = HCF_ALG_RSA,
467 .mode = HCF_ALG_MODE_NONE,
468 .paddingMode = HCF_OPENSSL_RSA_PSS_PADDING,
469 .md = HCF_OPENSSL_DIGEST_SHA256,
470 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
471 };
472 HcfCipherGeneratorSpi *spiObj = nullptr;
473 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
474
475 ASSERT_NE(res, HCF_SUCCESS);
476 ASSERT_EQ(spiObj, nullptr);
477 }
478
479 // init
480 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest029, TestSize.Level0)
481 {
482 CipherAttr params = {
483 .algo = HCF_ALG_RSA,
484 .mode = HCF_ALG_MODE_NONE,
485 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
486 .md = HCF_OPENSSL_DIGEST_SHA256,
487 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
488 };
489 HcfCipherGeneratorSpi *spiObj = nullptr;
490 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
491
492 ASSERT_EQ(res, HCF_SUCCESS);
493 ASSERT_NE(spiObj, nullptr);
494
495 res = spiObj->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
496 ASSERT_EQ(res, HCF_INVALID_PARAMS);
497
498 HcfObjDestroy(spiObj);
499 }
500
501 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest030, TestSize.Level0)
502 {
503 CipherAttr params = {
504 .algo = HCF_ALG_RSA,
505 .mode = HCF_ALG_MODE_NONE,
506 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
507 .md = HCF_OPENSSL_DIGEST_SHA256,
508 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
509 };
510 HcfCipherGeneratorSpi *spiObj = nullptr;
511 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
512
513 ASSERT_EQ(res, HCF_SUCCESS);
514 ASSERT_NE(spiObj, nullptr);
515
516 res = spiObj->init(spiObj, ENCRYPT_MODE, nullptr, nullptr);
517 ASSERT_EQ(res, HCF_INVALID_PARAMS);
518
519 HcfObjDestroy(spiObj);
520 }
521
522 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest031, TestSize.Level0)
523 {
524 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
525 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
526 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
527 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
528 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
529
530 HcfAsyKeyGeneratorBySpec *generator = nullptr;
531 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
532 EXPECT_EQ(res, HCF_SUCCESS);
533 HcfKeyPair *keyPair = nullptr;
534 res = generator->generateKeyPair(generator, &keyPair);
535 EXPECT_EQ(res, HCF_SUCCESS);
536 EXPECT_NE(keyPair, nullptr);
537
538 CipherAttr params = {
539 .algo = HCF_ALG_RSA,
540 .mode = HCF_ALG_MODE_NONE,
541 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
542 .md = HCF_OPENSSL_DIGEST_SHA256,
543 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
544 };
545 HcfCipherGeneratorSpi *spiObj = nullptr;
546 res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
547
548 ASSERT_EQ(res, HCF_SUCCESS);
549 ASSERT_NE(spiObj, nullptr);
550
551 res = spiObj->init(reinterpret_cast<HcfCipherGeneratorSpi *>(&g_obj),
552 ENCRYPT_MODE, reinterpret_cast<HcfKey *>(keyPair->priKey), nullptr);
553 ASSERT_EQ(res, HCF_INVALID_PARAMS);
554
555 HcfObjDestroy(keyPair);
556 HcfObjDestroy(generator);
557 HcfObjDestroy(spiObj);
558 }
559
560 // destroy
561 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest032, TestSize.Level0)
562 {
563 CipherAttr params = {
564 .algo = HCF_ALG_RSA,
565 .mode = HCF_ALG_MODE_NONE,
566 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
567 .md = HCF_OPENSSL_DIGEST_SHA256,
568 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
569 };
570 HcfCipherGeneratorSpi *spiObj = nullptr;
571 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
572
573 ASSERT_EQ(res, HCF_SUCCESS);
574 ASSERT_NE(spiObj, nullptr);
575
576 spiObj->base.destroy(nullptr);
577 ASSERT_NE(spiObj, nullptr);
578
579 HcfObjDestroy(spiObj);
580 }
581
582 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest033, TestSize.Level0)
583 {
584 CipherAttr params = {
585 .algo = HCF_ALG_RSA,
586 .mode = HCF_ALG_MODE_NONE,
587 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
588 .md = HCF_OPENSSL_DIGEST_SHA256,
589 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
590 };
591 HcfCipherGeneratorSpi *spiObj = nullptr;
592 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
593
594 ASSERT_EQ(res, HCF_SUCCESS);
595 ASSERT_NE(spiObj, nullptr);
596
597 spiObj->base.destroy(&g_obj);
598 ASSERT_NE(spiObj, nullptr);
599
600 HcfObjDestroy(spiObj);
601 }
602
603 // doFinal
604 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest034, TestSize.Level0)
605 {
606 CipherAttr params = {
607 .algo = HCF_ALG_RSA,
608 .mode = HCF_ALG_MODE_NONE,
609 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
610 .md = HCF_OPENSSL_DIGEST_SHA256,
611 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
612 };
613 HcfCipherGeneratorSpi *spiObj = nullptr;
614 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
615
616 ASSERT_EQ(res, HCF_SUCCESS);
617 ASSERT_NE(spiObj, nullptr);
618
619 res = spiObj->doFinal(nullptr, nullptr, nullptr);
620 ASSERT_EQ(res, HCF_INVALID_PARAMS);
621
622 HcfObjDestroy(spiObj);
623 }
624
625 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest035, TestSize.Level0)
626 {
627 CipherAttr params = {
628 .algo = HCF_ALG_RSA,
629 .mode = HCF_ALG_MODE_NONE,
630 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
631 .md = HCF_OPENSSL_DIGEST_SHA256,
632 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
633 };
634 HcfCipherGeneratorSpi *spiObj = nullptr;
635 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
636
637 ASSERT_EQ(res, HCF_SUCCESS);
638 ASSERT_NE(spiObj, nullptr);
639
640 res = spiObj->doFinal(spiObj, nullptr, nullptr);
641 ASSERT_EQ(res, HCF_INVALID_PARAMS);
642
643 HcfObjDestroy(spiObj);
644 }
645
646 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest036, TestSize.Level0)
647 {
648 uint8_t plan[] = "this is rsa cipher test!\0";
649 CipherAttr params = {
650 .algo = HCF_ALG_RSA,
651 .mode = HCF_ALG_MODE_NONE,
652 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
653 .md = HCF_OPENSSL_DIGEST_SHA256,
654 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
655 };
656 HcfCipherGeneratorSpi *spiObj = nullptr;
657 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
658
659 ASSERT_EQ(res, HCF_SUCCESS);
660 ASSERT_NE(spiObj, nullptr);
661
662 HcfBlob input = { .data = reinterpret_cast<uint8_t *>(plan),
663 .len = strlen(reinterpret_cast<char *>(plan)) };
664 res = spiObj->doFinal(spiObj, &input, nullptr);
665 ASSERT_EQ(res, HCF_INVALID_PARAMS);
666
667 HcfObjDestroy(spiObj);
668 }
669
670
671 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest037, TestSize.Level0)
672 {
673 uint8_t plan[] = "this is rsa cipher test!\0";
674 CipherAttr params = {
675 .algo = HCF_ALG_RSA,
676 .mode = HCF_ALG_MODE_NONE,
677 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
678 .md = HCF_OPENSSL_DIGEST_SHA256,
679 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
680 };
681 HcfCipherGeneratorSpi *spiObj = nullptr;
682 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
683
684 ASSERT_EQ(res, HCF_SUCCESS);
685 ASSERT_NE(spiObj, nullptr);
686
687 HcfBlob input = { .data = reinterpret_cast<uint8_t *>(plan),
688 .len = strlen(reinterpret_cast<char *>(plan)) };
689 HcfBlob output = { .data = nullptr, .len = 0 };
690 res = spiObj->doFinal(reinterpret_cast<HcfCipherGeneratorSpi *>(&g_obj), &input, &output);
691 ASSERT_EQ(res, HCF_INVALID_PARAMS);
692
693 HcfObjDestroy(spiObj);
694 }
695
696 HWTEST_F(CryptoRsaCipherSubTest, CryptoRsaCipherTest038, TestSize.Level0)
697 {
698 uint8_t plan[] = "this is rsa cipher test!\0";
699 CipherAttr params = {
700 .algo = HCF_ALG_RSA,
701 .mode = HCF_ALG_MODE_NONE,
702 .paddingMode = HCF_OPENSSL_RSA_PKCS1_PADDING,
703 .md = HCF_OPENSSL_DIGEST_SHA256,
704 .mgf1md = HCF_OPENSSL_DIGEST_SHA256,
705 };
706 HcfCipherGeneratorSpi *spiObj = nullptr;
707 HcfResult res = HcfCipherRsaCipherSpiCreate(¶ms, &spiObj);
708
709 ASSERT_EQ(res, HCF_SUCCESS);
710 ASSERT_NE(spiObj, nullptr);
711
712 HcfBlob input = { .data = reinterpret_cast<uint8_t *>(plan),
713 .len = strlen(reinterpret_cast<char *>(plan)) };
714 HcfBlob output = { .data = nullptr, .len = 0 };
715 res = spiObj->doFinal(spiObj, &input, &output);
716 ASSERT_EQ(res, HCF_INVALID_PARAMS);
717
718 HcfObjDestroy(spiObj);
719 }
720 }
721