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 <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "asy_key_generator.h"
20 #include "asy_key_generator_spi.h"
21 #include "blob.h"
22 #include "detailed_rsa_key_params.h"
23 #include "memory.h"
24 #include "openssl_adapter.h"
25 #include "openssl_class.h"
26 #include "openssl_common.h"
27 #include "rsa_asy_key_generator_openssl.h"
28
29 using namespace std;
30 using namespace testing::ext;
31
32 namespace {
33 class CryptoRsaAsyKeyGeneratorBySpecCovTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void CryptoRsaAsyKeyGeneratorBySpecCovTest::SetUpTestCase() {}
42
TearDownTestCase()43 void CryptoRsaAsyKeyGeneratorBySpecCovTest::TearDownTestCase() {}
44
SetUp()45 void CryptoRsaAsyKeyGeneratorBySpecCovTest::SetUp() {}
46
TearDown()47 void CryptoRsaAsyKeyGeneratorBySpecCovTest::TearDown() {}
48
49 namespace {
50 constexpr uint32_t RSA_2048_N_BYTE_SIZE = 256;
51 constexpr uint32_t RSA_2048_D_BYTE_SIZE = 256;
52 constexpr uint32_t RSA_2048_E_BYTE_SIZE = 3;
53 constexpr uint32_t OPENSSL_RSA_KEY_SIZE_2048 = 2048;
54 static const char *g_invalidAlgName = "null";
55
56 constexpr unsigned char CORRECT_N[] =
57 "\x92\x60\xd0\x75\x0a\xe1\x17\xee\xe5\x5c\x3f\x3d\xea\xba\x74\x91"
58 "\x75\x21\xa2\x62\xee\x76\x00\x7c\xdf\x8a\x56\x75\x5a\xd7\x3a\x15"
59 "\x98\xa1\x40\x84\x10\xa0\x14\x34\xc3\xf5\xbc\x54\xa8\x8b\x57\xfa"
60 "\x19\xfc\x43\x28\xda\xea\x07\x50\xa4\xc4\x4e\x88\xcf\xf3\xb2\x38"
61 "\x26\x21\xb8\x0f\x67\x04\x64\x43\x3e\x43\x36\xe6\xd0\x03\xe8\xcd"
62 "\x65\xbf\xf2\x11\xda\x14\x4b\x88\x29\x1c\x22\x59\xa0\x0a\x72\xb7"
63 "\x11\xc1\x16\xef\x76\x86\xe8\xfe\xe3\x4e\x4d\x93\x3c\x86\x81\x87"
64 "\xbd\xc2\x6f\x7b\xe0\x71\x49\x3c\x86\xf7\xa5\x94\x1c\x35\x10\x80"
65 "\x6a\xd6\x7b\x0f\x94\xd8\x8f\x5c\xf5\xc0\x2a\x09\x28\x21\xd8\x62"
66 "\x6e\x89\x32\xb6\x5c\x5b\xd8\xc9\x20\x49\xc2\x10\x93\x2b\x7a\xfa"
67 "\x7a\xc5\x9c\x0e\x88\x6a\xe5\xc1\xed\xb0\x0d\x8c\xe2\xc5\x76\x33"
68 "\xdb\x26\xbd\x66\x39\xbf\xf7\x3c\xee\x82\xbe\x92\x75\xc4\x02\xb4"
69 "\xcf\x2a\x43\x88\xda\x8c\xf8\xc6\x4e\xef\xe1\xc5\xa0\xf5\xab\x80"
70 "\x57\xc3\x9f\xa5\xc0\x58\x9c\x3e\x25\x3f\x09\x60\x33\x23\x00\xf9"
71 "\x4b\xea\x44\x87\x7b\x58\x8e\x1e\xdb\xde\x97\xcf\x23\x60\x72\x7a"
72 "\x09\xb7\x75\x26\x2d\x7e\xe5\x52\xb3\x31\x9b\x92\x66\xf0\x5a\x25";
73
74 constexpr unsigned char CORRECT_E[] = "\x01\x00\x01";
75
76 constexpr unsigned char CORRECT_D[] =
77 "\x6a\x7d\xf2\xca\x63\xea\xd4\xdd\xa1\x91\xd6\x14\xb6\xb3\x85\xe0"
78 "\xd9\x05\x6a\x3d\x6d\x5c\xfe\x07\xdb\x1d\xaa\xbe\xe0\x22\xdb\x08"
79 "\x21\x2d\x97\x61\x3d\x33\x28\xe0\x26\x7c\x9d\xd2\x3d\x78\x7a\xbd"
80 "\xe2\xaf\xcb\x30\x6a\xeb\x7d\xfc\xe6\x92\x46\xcc\x73\xf5\xc8\x7f"
81 "\xdf\x06\x03\x01\x79\xa2\x11\x4b\x76\x7d\xb1\xf0\x83\xff\x84\x1c"
82 "\x02\x5d\x7d\xc0\x0c\xd8\x24\x35\xb9\xa9\x0f\x69\x53\x69\xe9\x4d"
83 "\xf2\x3d\x2c\xe4\x58\xbc\x3b\x32\x83\xad\x8b\xba\x2b\x8f\xa1\xba"
84 "\x62\xe2\xdc\xe9\xac\xcf\xf3\x79\x9a\xae\x7c\x84\x00\x16\xf3\xba"
85 "\x8e\x00\x48\xc0\xb6\xcc\x43\x39\xaf\x71\x61\x00\x3a\x5b\xeb\x86"
86 "\x4a\x01\x64\xb2\xc1\xc9\x23\x7b\x64\xbc\x87\x55\x69\x94\x35\x1b"
87 "\x27\x50\x6c\x33\xd4\xbc\xdf\xce\x0f\x9c\x49\x1a\x7d\x6b\x06\x28"
88 "\xc7\xc8\x52\xbe\x4f\x0a\x9c\x31\x32\xb2\xed\x3a\x2c\x88\x81\xe9"
89 "\xaa\xb0\x7e\x20\xe1\x7d\xeb\x07\x46\x91\xbe\x67\x77\x76\xa7\x8b"
90 "\x5c\x50\x2e\x05\xd9\xbd\xde\x72\x12\x6b\x37\x38\x69\x5e\x2d\xd1"
91 "\xa0\xa9\x8a\x14\x24\x7c\x65\xd8\xa7\xee\x79\x43\x2a\x09\x2c\xb0"
92 "\x72\x1a\x12\xdf\x79\x8e\x44\xf7\xcf\xce\x0c\x49\x81\x47\xa9\xb1";
93
94 const char *g_rsaAlgName = "RSA";
95 }
96
GetMockClass(void)97 static const char *GetMockClass(void)
98 {
99 return "Mock";
100 }
101
102 static HcfObjectBase obj = {
103 .getClass = GetMockClass,
104 .destroy = nullptr
105 };
106
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)107 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
108 {
109 for (size_t i = 0; i < destLen; i++) {
110 dest[i] = str[i];
111 }
112 return;
113 }
114
EndianSwap(unsigned char * pData,int startIndex,int length)115 static void EndianSwap(unsigned char *pData, int startIndex, int length)
116 {
117 int cnt = length / 2;
118 int start = startIndex;
119 int end = startIndex + length - 1;
120 unsigned char tmp;
121 for (int i = 0; i < cnt; i++) {
122 tmp = pData[start + i];
123 pData[start + i] = pData[end - i];
124 pData[end - i] = tmp;
125 }
126 }
127
128 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)129 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
130 {
131 RemoveLastChar(CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
132 if (!IsBigEndian()) {
133 // the device is not big endian
134 EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
135 }
136 returnSpec->n.data = dataN;
137 returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
138 returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
139 returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
140 return;
141 }
142
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)143 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
144 HcfRsaKeyPairParamsSpec *returnPairSpec)
145 {
146 HcfRsaCommParamsSpec rsaCommSpec = {};
147 GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
148 RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
149 RemoveLastChar(CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
150 if (!IsBigEndian()) {
151 // the device is not big endian
152 EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
153 EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
154 }
155 returnPairSpec->pk.data = dataE;
156 returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
157 returnPairSpec->sk.data = dataD;
158 returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
159 returnPairSpec->base = rsaCommSpec;
160 returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
161 }
162
163 // spec generator spi
164 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest001, TestSize.Level0)
165 {
166 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
167 HcfAsyKeyGenParams params = {
168 .algo = HCF_ALG_RSA,
169 .bits = OPENSSL_RSA_KEY_SIZE_2048,
170 .primes = 0,
171 };
172
173 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
174 EXPECT_EQ(res, HCF_SUCCESS);
175 EXPECT_NE(spiObj, nullptr);
176
177 res = spiObj->engineGenerateKeyPairBySpec(nullptr, nullptr, nullptr);
178 EXPECT_NE(res, HCF_SUCCESS);
179 HcfObjDestroy(spiObj);
180 }
181
182 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest002, TestSize.Level0)
183 {
184 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
185 HcfAsyKeyGenParams params = {
186 .algo = HCF_ALG_RSA,
187 .bits = OPENSSL_RSA_KEY_SIZE_2048,
188 .primes = 0,
189 };
190
191 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
192 EXPECT_EQ(res, HCF_SUCCESS);
193 EXPECT_NE(spiObj, nullptr);
194
195 res = spiObj->engineGenerateKeyPairBySpec(spiObj, nullptr, nullptr);
196 EXPECT_NE(res, HCF_SUCCESS);
197 HcfObjDestroy(spiObj);
198 }
199
200 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest003, TestSize.Level0)
201 {
202 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
203 HcfAsyKeyGenParams params = {
204 .algo = HCF_ALG_RSA,
205 .bits = OPENSSL_RSA_KEY_SIZE_2048,
206 .primes = 0,
207 };
208
209 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
210 EXPECT_EQ(res, HCF_SUCCESS);
211 EXPECT_NE(spiObj, nullptr);
212
213 HcfKeyPair *keyPair = nullptr;
214 res = spiObj->engineGenerateKeyPairBySpec(spiObj, nullptr, &keyPair);
215 EXPECT_NE(res, HCF_SUCCESS);
216 EXPECT_EQ(keyPair, nullptr);
217
218 HcfObjDestroy(spiObj);
219 }
220
221 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest004, TestSize.Level0)
222 {
223 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
224 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
225 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
226 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
227 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
228 rsaPairSpec.base.base.algName = const_cast<char *>(g_invalidAlgName);
229
230 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
231 HcfAsyKeyGenParams params = {
232 .algo = HCF_ALG_RSA,
233 .bits = OPENSSL_RSA_KEY_SIZE_2048,
234 .primes = 0,
235 };
236
237 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
238 EXPECT_EQ(res, HCF_SUCCESS);
239 EXPECT_NE(spiObj, nullptr);
240
241 HcfKeyPair *keyPair = nullptr;
242 res = spiObj->engineGenerateKeyPairBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &keyPair);
243 EXPECT_NE(res, HCF_SUCCESS);
244 EXPECT_EQ(keyPair, nullptr);
245
246 HcfObjDestroy(spiObj);
247 }
248
249 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest005, TestSize.Level0)
250 {
251 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
252 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
253 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
254 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
255 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
256 rsaPairSpec.base.base.specType = HCF_COMMON_PARAMS_SPEC;
257
258 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
259 HcfAsyKeyGenParams params = {
260 .algo = HCF_ALG_RSA,
261 .bits = OPENSSL_RSA_KEY_SIZE_2048,
262 .primes = 0,
263 };
264
265 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
266 EXPECT_EQ(res, HCF_SUCCESS);
267 EXPECT_NE(spiObj, nullptr);
268
269 HcfKeyPair *keyPair = nullptr;
270 res = spiObj->engineGenerateKeyPairBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &keyPair);
271 EXPECT_NE(res, HCF_SUCCESS);
272 EXPECT_EQ(keyPair, nullptr);
273 HcfObjDestroy(spiObj);
274 }
275
276 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest006, TestSize.Level0)
277 {
278 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
279 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
280 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
281 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
282 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
283 rsaPairSpec.base.base.specType = HCF_COMMON_PARAMS_SPEC;
284
285 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
286 HcfAsyKeyGenParams params = {
287 .algo = HCF_ALG_RSA,
288 .bits = OPENSSL_RSA_KEY_SIZE_2048,
289 .primes = 0,
290 };
291
292 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
293 EXPECT_EQ(res, HCF_SUCCESS);
294 EXPECT_NE(spiObj, nullptr);
295
296 HcfKeyPair *keyPair = nullptr;
297 res = spiObj->engineGenerateKeyPairBySpec(reinterpret_cast<HcfAsyKeyGeneratorSpi *>(&obj),
298 reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &keyPair);
299 EXPECT_NE(res, HCF_SUCCESS);
300 EXPECT_EQ(keyPair, nullptr);
301 HcfObjDestroy(spiObj);
302 }
303
304 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest007, TestSize.Level0)
305 {
306 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
307 HcfAsyKeyGenParams params = {
308 .algo = HCF_ALG_RSA,
309 .bits = OPENSSL_RSA_KEY_SIZE_2048,
310 .primes = 0,
311 };
312
313 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
314 EXPECT_EQ(res, HCF_SUCCESS);
315 EXPECT_NE(spiObj, nullptr);
316
317 res = spiObj->engineGeneratePriKeyBySpec(nullptr, nullptr, nullptr);
318 EXPECT_NE(res, HCF_SUCCESS);
319 HcfObjDestroy(spiObj);
320 }
321
322 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest008, TestSize.Level0)
323 {
324 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
325 HcfAsyKeyGenParams params = {
326 .algo = HCF_ALG_RSA,
327 .bits = OPENSSL_RSA_KEY_SIZE_2048,
328 .primes = 0,
329 };
330
331 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
332 EXPECT_EQ(res, HCF_SUCCESS);
333 EXPECT_NE(spiObj, nullptr);
334
335 res = spiObj->engineGeneratePriKeyBySpec(spiObj, nullptr, nullptr);
336 EXPECT_NE(res, HCF_SUCCESS);
337 HcfObjDestroy(spiObj);
338 }
339
340 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest009, TestSize.Level0)
341 {
342 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
343 HcfAsyKeyGenParams params = {
344 .algo = HCF_ALG_RSA,
345 .bits = OPENSSL_RSA_KEY_SIZE_2048,
346 .primes = 0,
347 };
348
349 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
350 EXPECT_EQ(res, HCF_SUCCESS);
351 EXPECT_NE(spiObj, nullptr);
352
353 HcfPriKey *priKey = nullptr;
354 res = spiObj->engineGeneratePriKeyBySpec(spiObj, nullptr, &priKey);
355 EXPECT_NE(res, HCF_SUCCESS);
356 EXPECT_EQ(priKey, nullptr);
357
358 HcfObjDestroy(spiObj);
359 }
360
361 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest010, TestSize.Level0)
362 {
363 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
364 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
365 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
366 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
367 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
368 rsaPairSpec.base.base.algName = const_cast<char *>(g_invalidAlgName);
369
370 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
371 HcfAsyKeyGenParams params = {
372 .algo = HCF_ALG_RSA,
373 .bits = OPENSSL_RSA_KEY_SIZE_2048,
374 .primes = 0,
375 };
376
377 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
378 EXPECT_EQ(res, HCF_SUCCESS);
379 EXPECT_NE(spiObj, nullptr);
380
381 HcfPriKey *priKey = nullptr;
382 res = spiObj->engineGeneratePriKeyBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &priKey);
383 EXPECT_NE(res, HCF_SUCCESS);
384 EXPECT_EQ(priKey, nullptr);
385
386 HcfObjDestroy(spiObj);
387 }
388
389 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest011, TestSize.Level0)
390 {
391 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
392 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
393 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
394 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
395 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
396 rsaPairSpec.base.base.specType = HCF_COMMON_PARAMS_SPEC;
397
398 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
399 HcfAsyKeyGenParams params = {
400 .algo = HCF_ALG_RSA,
401 .bits = OPENSSL_RSA_KEY_SIZE_2048,
402 .primes = 0,
403 };
404
405 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
406 EXPECT_EQ(res, HCF_SUCCESS);
407 EXPECT_NE(spiObj, nullptr);
408
409 HcfPriKey *priKey = nullptr;
410 res = spiObj->engineGeneratePriKeyBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &priKey);
411 EXPECT_NE(res, HCF_SUCCESS);
412 EXPECT_EQ(priKey, nullptr);
413 HcfObjDestroy(spiObj);
414 }
415
416 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest012, TestSize.Level0)
417 {
418 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
419 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
420 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
421 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
422 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
423
424 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
425 HcfAsyKeyGenParams params = {
426 .algo = HCF_ALG_RSA,
427 .bits = OPENSSL_RSA_KEY_SIZE_2048,
428 .primes = 0,
429 };
430
431 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
432 EXPECT_EQ(res, HCF_SUCCESS);
433 EXPECT_NE(spiObj, nullptr);
434
435 HcfPriKey *priKey = nullptr;
436 res = spiObj->engineGeneratePriKeyBySpec(reinterpret_cast<HcfAsyKeyGeneratorSpi *>(&obj),
437 reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &priKey);
438 EXPECT_NE(res, HCF_SUCCESS);
439 EXPECT_EQ(priKey, nullptr);
440 HcfObjDestroy(spiObj);
441 }
442
443 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest013, TestSize.Level0)
444 {
445 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
446 HcfAsyKeyGenParams params = {
447 .algo = HCF_ALG_RSA,
448 .bits = OPENSSL_RSA_KEY_SIZE_2048,
449 .primes = 0,
450 };
451
452 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
453 EXPECT_EQ(res, HCF_SUCCESS);
454 EXPECT_NE(spiObj, nullptr);
455
456 res = spiObj->engineGeneratePubKeyBySpec(nullptr, nullptr, nullptr);
457 EXPECT_NE(res, HCF_SUCCESS);
458 HcfObjDestroy(spiObj);
459 }
460
461 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest014, TestSize.Level0)
462 {
463 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
464 HcfAsyKeyGenParams params = {
465 .algo = HCF_ALG_RSA,
466 .bits = OPENSSL_RSA_KEY_SIZE_2048,
467 .primes = 0,
468 };
469
470 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
471 EXPECT_EQ(res, HCF_SUCCESS);
472 EXPECT_NE(spiObj, nullptr);
473
474 res = spiObj->engineGeneratePubKeyBySpec(spiObj, nullptr, nullptr);
475 EXPECT_NE(res, HCF_SUCCESS);
476 HcfObjDestroy(spiObj);
477 }
478
479 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest015, TestSize.Level0)
480 {
481 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
482 HcfAsyKeyGenParams params = {
483 .algo = HCF_ALG_RSA,
484 .bits = OPENSSL_RSA_KEY_SIZE_2048,
485 .primes = 0,
486 };
487
488 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
489 EXPECT_EQ(res, HCF_SUCCESS);
490 EXPECT_NE(spiObj, nullptr);
491
492 HcfPubKey *pubKey = nullptr;
493 res = spiObj->engineGeneratePubKeyBySpec(spiObj, nullptr, &pubKey);
494 EXPECT_NE(res, HCF_SUCCESS);
495 EXPECT_EQ(pubKey, nullptr);
496
497 HcfObjDestroy(spiObj);
498 }
499
500 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest016, TestSize.Level0)
501 {
502 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
503 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
504 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
505 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
506 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
507 rsaPairSpec.base.base.algName = const_cast<char *>(g_invalidAlgName);
508
509 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
510 HcfAsyKeyGenParams params = {
511 .algo = HCF_ALG_RSA,
512 .bits = OPENSSL_RSA_KEY_SIZE_2048,
513 .primes = 0,
514 };
515
516 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
517 EXPECT_EQ(res, HCF_SUCCESS);
518 EXPECT_NE(spiObj, nullptr);
519
520 HcfPubKey *pubKey = nullptr;
521 res = spiObj->engineGeneratePubKeyBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &pubKey);
522 EXPECT_NE(res, HCF_SUCCESS);
523 EXPECT_EQ(pubKey, nullptr);
524
525 HcfObjDestroy(spiObj);
526 }
527
528 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest017, TestSize.Level0)
529 {
530 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
531 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
532 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
533 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
534 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
535 rsaPairSpec.base.base.specType = HCF_COMMON_PARAMS_SPEC;
536
537 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
538 HcfAsyKeyGenParams params = {
539 .algo = HCF_ALG_RSA,
540 .bits = OPENSSL_RSA_KEY_SIZE_2048,
541 .primes = 0,
542 };
543
544 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
545 EXPECT_EQ(res, HCF_SUCCESS);
546 EXPECT_NE(spiObj, nullptr);
547
548 HcfPubKey *pubKey = nullptr;
549 res = spiObj->engineGeneratePubKeyBySpec(spiObj, reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &pubKey);
550 EXPECT_NE(res, HCF_SUCCESS);
551 EXPECT_EQ(pubKey, nullptr);
552 HcfObjDestroy(spiObj);
553 }
554
555 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest018, TestSize.Level0)
556 {
557 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
558 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
559 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
560 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
561 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
562
563 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
564 HcfAsyKeyGenParams params = {
565 .algo = HCF_ALG_RSA,
566 .bits = OPENSSL_RSA_KEY_SIZE_2048,
567 .primes = 0,
568 };
569
570 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
571 EXPECT_EQ(res, HCF_SUCCESS);
572 EXPECT_NE(spiObj, nullptr);
573
574 HcfPubKey *pubKey = nullptr;
575 res = spiObj->engineGeneratePubKeyBySpec(reinterpret_cast<HcfAsyKeyGeneratorSpi *>(&obj),
576 reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &pubKey);
577 EXPECT_NE(res, HCF_SUCCESS);
578 EXPECT_EQ(pubKey, nullptr);
579 HcfObjDestroy(spiObj);
580 }
581
582 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest019, TestSize.Level0)
583 {
584 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
585 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
586 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
587 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
588 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
589
590 HcfAsyKeyGeneratorBySpec *generator = nullptr;
591 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
592 EXPECT_EQ(res, HCF_SUCCESS);
593 EXPECT_NE(generator, nullptr);
594
595 HcfKeyPair *keyPair = nullptr;
596 res = generator->generateKeyPair(generator, &keyPair);
597 EXPECT_EQ(res, HCF_SUCCESS);
598 EXPECT_NE(keyPair, nullptr);
599
600 res = keyPair->pubKey->getAsyKeySpecBigInteger(nullptr, RSA_N_BN, nullptr);
601 EXPECT_NE(res, HCF_SUCCESS);
602 HcfObjDestroy(keyPair);
603 HcfObjDestroy(generator);
604 }
605
606 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest020, TestSize.Level0)
607 {
608 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
609 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
610 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
611 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
612 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
613
614 HcfAsyKeyGeneratorBySpec *generator = nullptr;
615 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
616 EXPECT_EQ(res, HCF_SUCCESS);
617 EXPECT_NE(generator, nullptr);
618
619 HcfKeyPair *keyPair = nullptr;
620 res = generator->generateKeyPair(generator, &keyPair);
621 EXPECT_EQ(res, HCF_SUCCESS);
622 EXPECT_NE(keyPair, nullptr);
623
624 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_N_BN, nullptr);
625 EXPECT_NE(res, HCF_SUCCESS);
626 HcfObjDestroy(keyPair);
627 HcfObjDestroy(generator);
628 }
629
630 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest021, TestSize.Level0)
631 {
632 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
633 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
634 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
635 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
636 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
637
638 HcfAsyKeyGeneratorBySpec *generator = nullptr;
639 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
640 EXPECT_EQ(res, HCF_SUCCESS);
641 EXPECT_NE(generator, nullptr);
642
643 HcfKeyPair *keyPair = nullptr;
644 res = generator->generateKeyPair(generator, &keyPair);
645 EXPECT_EQ(res, HCF_SUCCESS);
646 EXPECT_NE(keyPair, nullptr);
647
648 HcfBigInteger retN = { .data = nullptr, .len = 0 };
649 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_SK_BN, &retN);
650 EXPECT_NE(res, HCF_SUCCESS);
651 EXPECT_EQ(retN.data, nullptr);
652 HcfObjDestroy(keyPair);
653 HcfObjDestroy(generator);
654 }
655
656 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest022, TestSize.Level0)
657 {
658 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
659 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
660 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
661 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
662 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
663
664 HcfAsyKeyGeneratorBySpec *generator = nullptr;
665 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
666 EXPECT_EQ(res, HCF_SUCCESS);
667 EXPECT_NE(generator, nullptr);
668
669 HcfKeyPair *keyPair = nullptr;
670 res = generator->generateKeyPair(generator, &keyPair);
671 EXPECT_EQ(res, HCF_SUCCESS);
672 EXPECT_NE(keyPair, nullptr);
673
674 HcfBigInteger retN = { .data = nullptr, .len = 0 };
675 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_PK_BN, &retN);
676 EXPECT_NE(res, HCF_SUCCESS);
677 EXPECT_EQ(retN.data, nullptr);
678 HcfObjDestroy(keyPair);
679 HcfObjDestroy(generator);
680 }
681
682 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest023, TestSize.Level0)
683 {
684 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
685 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
686 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
687 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
688 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
689
690 HcfAsyKeyGeneratorBySpec *generator = nullptr;
691 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
692 EXPECT_EQ(res, HCF_SUCCESS);
693 EXPECT_NE(generator, nullptr);
694
695 HcfKeyPair *keyPair = nullptr;
696 res = generator->generateKeyPair(generator, &keyPair);
697 EXPECT_EQ(res, HCF_SUCCESS);
698 EXPECT_NE(keyPair, nullptr);
699
700 HcfBigInteger retN = { .data = nullptr, .len = 0 };
701 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_PK_BN, nullptr);
702 EXPECT_NE(res, HCF_SUCCESS);
703 EXPECT_EQ(retN.data, nullptr);
704 HcfObjDestroy(keyPair);
705 HcfObjDestroy(generator);
706 }
707
708 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest024, TestSize.Level0)
709 {
710 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
711 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
712 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
713 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
714 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
715
716 HcfAsyKeyGeneratorBySpec *generator = nullptr;
717 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
718 EXPECT_EQ(res, HCF_SUCCESS);
719 EXPECT_NE(generator, nullptr);
720
721 HcfKeyPair *keyPair = nullptr;
722 res = generator->generateKeyPair(generator, &keyPair);
723 EXPECT_EQ(res, HCF_SUCCESS);
724 EXPECT_NE(keyPair, nullptr);
725
726 HcfBigInteger retN = { .data = nullptr, .len = 0 };
727 res = keyPair->priKey->getAsyKeySpecBigInteger(nullptr, RSA_PK_BN, &retN);
728 EXPECT_NE(res, HCF_SUCCESS);
729 EXPECT_EQ(retN.data, nullptr);
730 HcfObjDestroy(keyPair);
731 HcfObjDestroy(generator);
732 }
733
734 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest025, TestSize.Level0)
735 {
736 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
737 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
738 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
739 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
740 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
741
742 HcfAsyKeyGeneratorBySpec *generator = nullptr;
743 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
744 EXPECT_EQ(res, HCF_SUCCESS);
745 EXPECT_NE(generator, nullptr);
746
747 HcfKeyPair *keyPair = nullptr;
748 res = generator->generateKeyPair(generator, &keyPair);
749 EXPECT_EQ(res, HCF_SUCCESS);
750 EXPECT_NE(keyPair, nullptr);
751
752 HcfAsyKeyGenerator *generatorEcc = nullptr;
753 res = HcfAsyKeyGeneratorCreate("ECC256", &generatorEcc);
754 EXPECT_EQ(res, HCF_SUCCESS);
755 HcfKeyPair *keyPairEcc = nullptr;
756 res = generatorEcc->generateKeyPair(generatorEcc, nullptr, &keyPairEcc);
757 EXPECT_EQ(res, HCF_SUCCESS);
758 EXPECT_NE(keyPairEcc, nullptr);
759
760 HcfBigInteger retN = { .data = nullptr, .len = 0 };
761 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPairEcc->priKey, RSA_PK_BN, &retN);
762 EXPECT_NE(res, HCF_SUCCESS);
763 EXPECT_EQ(retN.data, nullptr);
764
765 HcfObjDestroy(keyPair);
766 HcfObjDestroy(generator);
767 HcfObjDestroy(keyPairEcc);
768 HcfObjDestroy(generatorEcc);
769 }
770
771 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest026, TestSize.Level0)
772 {
773 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
774 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
775 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
776 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
777 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
778
779 HcfAsyKeyGeneratorBySpec *generator = nullptr;
780 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
781 EXPECT_EQ(res, HCF_SUCCESS);
782 EXPECT_NE(generator, nullptr);
783
784 HcfKeyPair *keyPair = nullptr;
785 res = generator->generateKeyPair(generator, &keyPair);
786 EXPECT_EQ(res, HCF_SUCCESS);
787 EXPECT_NE(keyPair, nullptr);
788
789 HcfAsyKeyGenerator *generatorEcc = nullptr;
790 res = HcfAsyKeyGeneratorCreate("ECC256", &generatorEcc);
791 EXPECT_EQ(res, HCF_SUCCESS);
792 HcfKeyPair *keyPairEcc = nullptr;
793 res = generatorEcc->generateKeyPair(generatorEcc, nullptr, &keyPairEcc);
794 EXPECT_EQ(res, HCF_SUCCESS);
795 EXPECT_NE(keyPairEcc, nullptr);
796
797
798 HcfBigInteger retN = { .data = nullptr, .len = 0 };
799 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPairEcc->pubKey, RSA_SK_BN, &retN);
800 EXPECT_NE(res, HCF_SUCCESS);
801 EXPECT_EQ(retN.data, nullptr);
802 HcfObjDestroy(keyPair);
803 HcfObjDestroy(generator);
804 HcfObjDestroy(keyPairEcc);
805 HcfObjDestroy(generatorEcc);
806 }
807
808 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest033, TestSize.Level0)
809 {
810 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
811 HcfAsyKeyGenParams params = {
812 .algo = HCF_ALG_RSA,
813 .bits = OPENSSL_RSA_KEY_SIZE_2048,
814 .primes = 0,
815 };
816
817 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
818 EXPECT_EQ(res, HCF_SUCCESS);
819 EXPECT_NE(spiObj, nullptr);
820
821 HcfKeyPair *keyPair = nullptr;
822 res = spiObj->engineGenerateKeyPair(reinterpret_cast<HcfAsyKeyGeneratorSpi *>(&obj), &keyPair);
823 EXPECT_NE(res, HCF_SUCCESS);
824 EXPECT_EQ(keyPair, nullptr);
825
826 HcfObjDestroy(spiObj);
827 }
828
829 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest034, TestSize.Level0)
830 {
831 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
832 HcfAsyKeyGenParams params = {
833 .algo = HCF_ALG_RSA,
834 .bits = OPENSSL_RSA_KEY_SIZE_2048,
835 .primes = 0,
836 };
837
838 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
839 EXPECT_EQ(res, HCF_SUCCESS);
840 EXPECT_NE(spiObj, nullptr);
841
842 res = spiObj->engineConvertKey(nullptr, nullptr, nullptr, nullptr, nullptr);
843 EXPECT_NE(res, HCF_SUCCESS);
844
845 HcfObjDestroy(spiObj);
846 }
847
848 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest035, TestSize.Level0)
849 {
850 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
851 HcfAsyKeyGenParams params = {
852 .algo = HCF_ALG_RSA,
853 .bits = OPENSSL_RSA_KEY_SIZE_2048,
854 .primes = 0,
855 };
856
857 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
858 EXPECT_EQ(res, HCF_SUCCESS);
859 EXPECT_NE(spiObj, nullptr);
860
861 HcfKeyPair *keyPair = nullptr;
862 res = spiObj->engineConvertKey(spiObj, nullptr, nullptr, nullptr, &keyPair);
863 EXPECT_NE(res, HCF_SUCCESS);
864 EXPECT_EQ(keyPair, nullptr);
865
866 HcfObjDestroy(spiObj);
867 }
868
869 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest036, TestSize.Level0)
870 {
871 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
872 HcfAsyKeyGenParams params = {
873 .algo = HCF_ALG_RSA,
874 .bits = OPENSSL_RSA_KEY_SIZE_2048,
875 .primes = 0,
876 };
877
878 HcfBlob pubBlob = { .data = nullptr, .len = 0 };
879 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
880 EXPECT_EQ(res, HCF_SUCCESS);
881 EXPECT_NE(spiObj, nullptr);
882
883 HcfKeyPair *keyPair = nullptr;
884 res = spiObj->engineConvertKey(reinterpret_cast<HcfAsyKeyGeneratorSpi *>(&obj),
885 nullptr, &pubBlob, nullptr, &keyPair);
886 EXPECT_NE(res, HCF_SUCCESS);
887 EXPECT_EQ(keyPair, nullptr);
888
889 HcfObjDestroy(spiObj);
890 }
891
892 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest037, TestSize.Level0)
893 {
894 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
895 HcfAsyKeyGenParams params = {
896 .algo = HCF_ALG_RSA,
897 .bits = OPENSSL_RSA_KEY_SIZE_2048,
898 .primes = 0,
899 };
900
901 HcfBlob pubBlob = { .data = nullptr, .len = 0 };
902 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
903 EXPECT_EQ(res, HCF_SUCCESS);
904 EXPECT_NE(spiObj, nullptr);
905
906 HcfKeyPair *keyPair = nullptr;
907 res = spiObj->engineConvertKey(spiObj, nullptr, &pubBlob, nullptr, &keyPair);
908 EXPECT_NE(res, HCF_SUCCESS);
909 EXPECT_EQ(keyPair, nullptr);
910
911 HcfObjDestroy(spiObj);
912 }
913
914 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest038, TestSize.Level0)
915 {
916 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
917 HcfAsyKeyGenParams params = {
918 .algo = HCF_ALG_RSA,
919 .bits = OPENSSL_RSA_KEY_SIZE_2048,
920 .primes = 0,
921 };
922
923 HcfBlob pubBlob = { .data = nullptr, .len = OPENSSL_RSA_KEY_SIZE_2048 };
924 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
925 EXPECT_EQ(res, HCF_SUCCESS);
926 EXPECT_NE(spiObj, nullptr);
927
928 HcfKeyPair *keyPair = nullptr;
929 res = spiObj->engineConvertKey(spiObj, nullptr, &pubBlob, nullptr, &keyPair);
930 EXPECT_NE(res, HCF_SUCCESS);
931 EXPECT_EQ(keyPair, nullptr);
932
933 HcfObjDestroy(spiObj);
934 }
935
936 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest039, TestSize.Level0)
937 {
938 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
939 HcfAsyKeyGenParams params = {
940 .algo = HCF_ALG_RSA,
941 .bits = OPENSSL_RSA_KEY_SIZE_2048,
942 .primes = 0,
943 };
944
945 HcfBlob priBlob = { .data = nullptr, .len = 0 };
946 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
947 EXPECT_EQ(res, HCF_SUCCESS);
948 EXPECT_NE(spiObj, nullptr);
949
950 HcfKeyPair *keyPair = nullptr;
951 res = spiObj->engineConvertKey(spiObj, nullptr, nullptr, &priBlob, &keyPair);
952 EXPECT_NE(res, HCF_SUCCESS);
953 EXPECT_EQ(keyPair, nullptr);
954
955 HcfObjDestroy(spiObj);
956 }
957
958 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest040, TestSize.Level0)
959 {
960 HcfAsyKeyGeneratorSpi *spiObj = nullptr;
961 HcfAsyKeyGenParams params = {
962 .algo = HCF_ALG_RSA,
963 .bits = OPENSSL_RSA_KEY_SIZE_2048,
964 .primes = 0,
965 };
966
967 HcfBlob priBlob = { .data = nullptr, .len = OPENSSL_RSA_KEY_SIZE_2048 };
968 HcfResult res = HcfAsyKeyGeneratorSpiRsaCreate(¶ms, &spiObj);
969 EXPECT_EQ(res, HCF_SUCCESS);
970 EXPECT_NE(spiObj, nullptr);
971
972 HcfKeyPair *keyPair = nullptr;
973 res = spiObj->engineConvertKey(spiObj, nullptr, nullptr, &priBlob, &keyPair);
974 EXPECT_NE(res, HCF_SUCCESS);
975 EXPECT_EQ(keyPair, nullptr);
976
977 HcfObjDestroy(spiObj);
978 }
979
980 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest041, TestSize.Level0)
981 {
982 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
983 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
984 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
985 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
986 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
987
988 HcfAsyKeyGeneratorBySpec *generator = nullptr;
989 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
990 EXPECT_EQ(res, HCF_SUCCESS);
991 EXPECT_NE(generator, nullptr);
992
993 HcfKeyPair *keyPair = nullptr;
994 res = generator->generateKeyPair(generator, &keyPair);
995 EXPECT_EQ(res, HCF_SUCCESS);
996 EXPECT_NE(keyPair, nullptr);
997
998 res = keyPair->priKey->base.getEncoded(nullptr, nullptr);
999 EXPECT_NE(res, HCF_SUCCESS);
1000
1001 HcfObjDestroy(keyPair);
1002 HcfObjDestroy(generator);
1003 }
1004
1005 HWTEST_F(CryptoRsaAsyKeyGeneratorBySpecCovTest, CryptoRsaAsyKeyGeneratorBySpecCovTest042, TestSize.Level0)
1006 {
1007 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1008 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1009 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1010 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1011 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1012
1013 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1014 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1015 EXPECT_EQ(res, HCF_SUCCESS);
1016 EXPECT_NE(generator, nullptr);
1017
1018 HcfKeyPair *keyPair = nullptr;
1019 res = generator->generateKeyPair(generator, &keyPair);
1020 EXPECT_EQ(res, HCF_SUCCESS);
1021 EXPECT_NE(keyPair, nullptr);
1022
1023 res = keyPair->pubKey->base.getEncoded(nullptr, nullptr);
1024 EXPECT_NE(res, HCF_SUCCESS);
1025
1026 HcfObjDestroy(keyPair);
1027 HcfObjDestroy(generator);
1028 }
1029 }
1030