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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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(&params, &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