1 /*
2  * Copyright (C) 2022-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 CryptoRsaCipherTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
SetUpTestCase()39 void CryptoRsaCipherTest::SetUpTestCase() {}
TearDownTestCase()40 void CryptoRsaCipherTest::TearDownTestCase() {}
SetUp()41 void CryptoRsaCipherTest::SetUp() {}
TearDown()42 void CryptoRsaCipherTest::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 const char *g_mdName = "SHA256";
89 const char *g_mgf1Name = "MGF1";
90 
91 }
92 
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)93 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
94 {
95     for (size_t i = 0; i < destLen; i++) {
96         dest[i] = str[i];
97     }
98     return;
99 }
100 
EndianSwap(unsigned char * pData,int startIndex,int length)101 static void EndianSwap(unsigned char *pData, int startIndex, int length)
102 {
103     int cnt = length / 2;
104     int start = startIndex;
105     int end  = startIndex + length - 1;
106     unsigned char tmp;
107     for (int i = 0; i < cnt; i++) {
108         tmp = pData[start + i];
109         pData[start + i] = pData[end - i];
110         pData[end - i] = tmp;
111     }
112 }
113 
114 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)115 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
116 {
117     RemoveLastChar(CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
118     if (!IsBigEndian()) {
119         // the device is not big endian
120         EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
121     }
122     returnSpec->n.data = dataN;
123     returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
124     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
125     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
126     return;
127 }
128 
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)129 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
130     HcfRsaKeyPairParamsSpec *returnPairSpec)
131 {
132     HcfRsaCommParamsSpec rsaCommSpec = {};
133     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
134     RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
135     RemoveLastChar(CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
136     if (!IsBigEndian()) {
137         // the device is not big endian
138         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
139         EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
140     }
141     returnPairSpec->pk.data = dataE;
142     returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
143     returnPairSpec->sk.data = dataD;
144     returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
145     returnPairSpec->base = rsaCommSpec;
146     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
147 }
148 
RsaCipherSpec(HcfCipher * cipher)149 static HcfResult RsaCipherSpec(HcfCipher *cipher)
150 {
151     uint8_t pSourceData[] = "123456\0";
152     HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
153     HcfResult res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
154     EXPECT_EQ(res, HCF_SUCCESS);
155 
156     char *returnMdName = nullptr;
157     res = cipher->getCipherSpecString(cipher, OAEP_MD_NAME_STR, &returnMdName);
158     EXPECT_EQ(res, HCF_SUCCESS);
159     EXPECT_STREQ(g_mdName, returnMdName);
160     char *returnMgF1Name = nullptr;
161     res = cipher->getCipherSpecString(cipher, OAEP_MGF_NAME_STR, &returnMgF1Name);
162     EXPECT_EQ(res, HCF_SUCCESS);
163     EXPECT_STREQ(g_mgf1Name, returnMgF1Name);
164     char *returnMgf1MdName = nullptr;
165     res = cipher->getCipherSpecString(cipher, OAEP_MGF1_MD_STR, &returnMgf1MdName);
166     EXPECT_EQ(res, HCF_SUCCESS);
167     EXPECT_STREQ(g_mdName, returnMgf1MdName);
168 
169     HcfBlob pSourceReturn = {.data = nullptr, .len = 0};
170     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, &pSourceReturn);
171     EXPECT_EQ(res, HCF_SUCCESS);
172     int resCmp = memcmp(pSourceReturn.data, pSourceData, pSourceReturn.len);
173     EXPECT_EQ(resCmp, HCF_SUCCESS);
174 
175     HcfFree(pSourceReturn.data);
176     HcfFree(returnMdName);
177     HcfFree(returnMgF1Name);
178     HcfFree(returnMgf1MdName);
179     return res;
180 }
181 
RsaSpecpSource(HcfCipher * cipher,uint8_t * pSourceData,HcfBlob pSource)182 static HcfResult RsaSpecpSource(HcfCipher *cipher, uint8_t *pSourceData, HcfBlob pSource)
183 {
184     HcfBlob cleanP = { .data = nullptr, .len = 0 };
185     HcfBlob pSourceReturn = {.data = nullptr, .len = 0};
186     // test cipher psource set、get before init & set clean.
187     HcfResult res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
188     EXPECT_EQ(res, HCF_SUCCESS);
189     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, &pSourceReturn);
190     EXPECT_EQ(res, HCF_SUCCESS);
191     int resCmp = memcmp(pSourceReturn.data, pSourceData, pSourceReturn.len);
192     EXPECT_EQ(resCmp, HCF_SUCCESS);
193 
194     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, cleanP);
195     EXPECT_EQ(res, HCF_SUCCESS);
196     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, &pSourceReturn);
197     EXPECT_NE(res, HCF_SUCCESS) << "after clean, cannot get Psource";
198 
199     HcfBlob pSourceReturn2 = {.data = nullptr, .len = 0};
200     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
201     EXPECT_EQ(res, HCF_SUCCESS);
202     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, &pSourceReturn2);
203     EXPECT_EQ(res, HCF_SUCCESS);
204     resCmp = memcmp(pSourceReturn2.data, pSourceData, pSourceReturn.len);
205     EXPECT_EQ(resCmp, 0);
206     HcfFree(pSourceReturn2.data);
207     HcfFree(pSourceReturn.data);
208     return res;
209 }
210 
211 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest90, TestSize.Level0)
212 {
213     HcfResult res = HCF_SUCCESS;
214     HcfCipher *cipher = nullptr;
215     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
216     EXPECT_EQ(res, HCF_SUCCESS);
217     EXPECT_NE(cipher, nullptr);
218     EXPECT_NE(cipher->base.getClass(), nullptr);
219     EXPECT_NE(cipher->base.destroy, nullptr);
220     EXPECT_NE(cipher->init, nullptr);
221     EXPECT_NE(cipher->update, nullptr);
222     EXPECT_NE(cipher->doFinal, nullptr);
223     EXPECT_NE(cipher->getAlgorithm, nullptr);
224     HcfObjDestroy(cipher);
225 }
226 
227 
228 // HcfCipherCreate correct case: RSAXXX + padding
229 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest100, TestSize.Level0)
230 {
231     HcfResult res = HCF_SUCCESS;
232     HcfCipher *cipher = nullptr;
233     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
234     EXPECT_EQ(res, HCF_SUCCESS);
235     EXPECT_NE(cipher, nullptr);
236     EXPECT_NE(cipher->base.getClass(), nullptr);
237     EXPECT_NE(cipher->base.destroy, nullptr);
238     EXPECT_NE(cipher->init, nullptr);
239     EXPECT_NE(cipher->update, nullptr);
240     EXPECT_NE(cipher->doFinal, nullptr);
241     HcfObjDestroy(cipher);
242 }
243 
244 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest110, TestSize.Level0)
245 {
246     HcfResult res = HCF_SUCCESS;
247     HcfCipher *cipher = nullptr;
248     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
249     EXPECT_EQ(res, HCF_SUCCESS);
250     EXPECT_NE(cipher, nullptr);
251     EXPECT_NE(cipher->base.getClass(), nullptr);
252     EXPECT_NE(cipher->base.destroy, nullptr);
253     EXPECT_NE(cipher->init, nullptr);
254     EXPECT_NE(cipher->update, nullptr);
255     EXPECT_NE(cipher->doFinal, nullptr);
256     HcfObjDestroy(cipher);
257 }
258 
259 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest120, TestSize.Level0)
260 {
261     HcfResult res = HCF_SUCCESS;
262     HcfCipher *cipher = nullptr;
263     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
264     EXPECT_EQ(res, HCF_SUCCESS);
265     EXPECT_NE(cipher, nullptr);
266     EXPECT_NE(cipher->base.getClass(), nullptr);
267     EXPECT_NE(cipher->base.destroy, nullptr);
268     EXPECT_NE(cipher->init, nullptr);
269     EXPECT_NE(cipher->update, nullptr);
270     EXPECT_NE(cipher->doFinal, nullptr);
271     HcfObjDestroy(cipher);
272 }
273 
274 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest130, TestSize.Level0)
275 {
276     HcfResult res = HCF_SUCCESS;
277     HcfCipher *cipher = nullptr;
278     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher);
279     EXPECT_EQ(res, HCF_SUCCESS);
280     EXPECT_NE(cipher, nullptr);
281     EXPECT_NE(cipher->base.getClass(), nullptr);
282     EXPECT_NE(cipher->base.destroy, nullptr);
283     EXPECT_NE(cipher->init, nullptr);
284     EXPECT_NE(cipher->update, nullptr);
285     EXPECT_NE(cipher->doFinal, nullptr);
286     HcfObjDestroy(cipher);
287 }
288 
289 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest140, TestSize.Level0)
290 {
291     HcfResult res = HCF_SUCCESS;
292     HcfCipher *cipher = nullptr;
293     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
294     EXPECT_EQ(res, HCF_SUCCESS);
295     EXPECT_NE(cipher, nullptr);
296     EXPECT_NE(cipher->base.getClass(), nullptr);
297     EXPECT_NE(cipher->base.destroy, nullptr);
298     EXPECT_NE(cipher->init, nullptr);
299     EXPECT_NE(cipher->update, nullptr);
300     EXPECT_NE(cipher->doFinal, nullptr);
301     HcfObjDestroy(cipher);
302 }
303 
304 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest150, TestSize.Level0)
305 {
306     HcfResult res = HCF_SUCCESS;
307     HcfCipher *cipher = nullptr;
308     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA512|MGF1_SHA256", &cipher);
309     EXPECT_EQ(res, HCF_SUCCESS);
310     EXPECT_NE(cipher, nullptr);
311     EXPECT_NE(cipher->base.getClass(), nullptr);
312     EXPECT_NE(cipher->base.destroy, nullptr);
313     EXPECT_NE(cipher->init, nullptr);
314     EXPECT_NE(cipher->update, nullptr);
315     EXPECT_NE(cipher->doFinal, nullptr);
316     HcfObjDestroy(cipher);
317 }
318 
319 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest160, TestSize.Level0)
320 {
321     HcfResult res = HCF_SUCCESS;
322     HcfCipher *cipher = nullptr;
323     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA256", &cipher);
324     EXPECT_EQ(res, HCF_SUCCESS);
325     EXPECT_NE(cipher, nullptr);
326     EXPECT_NE(cipher->base.getClass(), nullptr);
327     EXPECT_NE(cipher->base.destroy, nullptr);
328     EXPECT_NE(cipher->init, nullptr);
329     EXPECT_NE(cipher->update, nullptr);
330     EXPECT_NE(cipher->doFinal, nullptr);
331     HcfObjDestroy(cipher);
332 }
333 
334 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest170, TestSize.Level0)
335 {
336     HcfResult res = HCF_SUCCESS;
337     HcfCipher *cipher = nullptr;
338     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA1", &cipher);
339     EXPECT_EQ(res, HCF_SUCCESS);
340     EXPECT_NE(cipher, nullptr);
341     EXPECT_NE(cipher->base.getClass(), nullptr);
342     EXPECT_NE(cipher->base.destroy, nullptr);
343     EXPECT_NE(cipher->init, nullptr);
344     EXPECT_NE(cipher->update, nullptr);
345     EXPECT_NE(cipher->doFinal, nullptr);
346     HcfObjDestroy(cipher);
347 }
348 
349 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest180, TestSize.Level0)
350 {
351     HcfResult res = HCF_SUCCESS;
352     HcfCipher *cipher = nullptr;
353     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_MD5", &cipher);
354     EXPECT_EQ(res, HCF_SUCCESS);
355     EXPECT_NE(cipher, nullptr);
356     EXPECT_NE(cipher->base.getClass(), nullptr);
357     EXPECT_NE(cipher->base.destroy, nullptr);
358     EXPECT_NE(cipher->init, nullptr);
359     EXPECT_NE(cipher->update, nullptr);
360     EXPECT_NE(cipher->doFinal, nullptr);
361     HcfObjDestroy(cipher);
362 }
363 
364 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest190, TestSize.Level0)
365 {
366     HcfResult res = HCF_SUCCESS;
367     HcfCipher *cipher = nullptr;
368     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA1|MGF1_SHA512", &cipher);
369     EXPECT_EQ(res, HCF_SUCCESS);
370     EXPECT_NE(cipher, nullptr);
371     EXPECT_NE(cipher->base.getClass(), nullptr);
372     EXPECT_NE(cipher->base.destroy, nullptr);
373     EXPECT_NE(cipher->init, nullptr);
374     EXPECT_NE(cipher->update, nullptr);
375     EXPECT_NE(cipher->doFinal, nullptr);
376     HcfObjDestroy(cipher);
377 }
378 
379 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest200, TestSize.Level0)
380 {
381     HcfResult res = HCF_SUCCESS;
382     HcfCipher *cipher = nullptr;
383     res = HcfCipherCreate("RSA512|NoPadding", &cipher);
384     EXPECT_EQ(res, HCF_SUCCESS);
385     EXPECT_NE(cipher, nullptr);
386     EXPECT_NE(cipher->base.getClass(), nullptr);
387     EXPECT_NE(cipher->base.destroy, nullptr);
388     EXPECT_NE(cipher->init, nullptr);
389     EXPECT_NE(cipher->update, nullptr);
390     EXPECT_NE(cipher->doFinal, nullptr);
391     HcfObjDestroy(cipher);
392 }
393 
394 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest210, TestSize.Level0)
395 {
396     HcfResult res = HCF_SUCCESS;
397     HcfCipher *cipher = nullptr;
398     res = HcfCipherCreate("RSA768|NoPadding", &cipher);
399     EXPECT_EQ(res, HCF_SUCCESS);
400     EXPECT_NE(cipher, nullptr);
401     EXPECT_NE(cipher->base.getClass(), nullptr);
402     EXPECT_NE(cipher->base.destroy, nullptr);
403     EXPECT_NE(cipher->init, nullptr);
404     EXPECT_NE(cipher->update, nullptr);
405     EXPECT_NE(cipher->doFinal, nullptr);
406     HcfObjDestroy(cipher);
407 }
408 
409 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest220, TestSize.Level0)
410 {
411     HcfResult res = HCF_SUCCESS;
412     HcfCipher *cipher = nullptr;
413     res = HcfCipherCreate("RSA2048|NoPadding", &cipher);
414     EXPECT_EQ(res, HCF_SUCCESS);
415     EXPECT_NE(cipher, nullptr);
416     EXPECT_NE(cipher->base.getClass(), nullptr);
417     EXPECT_NE(cipher->base.destroy, nullptr);
418     EXPECT_NE(cipher->init, nullptr);
419     EXPECT_NE(cipher->update, nullptr);
420     EXPECT_NE(cipher->doFinal, nullptr);
421     HcfObjDestroy(cipher);
422 }
423 
424 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest230, TestSize.Level0)
425 {
426     HcfResult res = HCF_SUCCESS;
427     HcfCipher *cipher = nullptr;
428     res = HcfCipherCreate("RSA512|PKCS1", &cipher);
429     EXPECT_EQ(res, HCF_SUCCESS);
430     EXPECT_NE(cipher, nullptr);
431     EXPECT_NE(cipher->base.getClass(), nullptr);
432     EXPECT_NE(cipher->base.destroy, nullptr);
433     EXPECT_NE(cipher->init, nullptr);
434     EXPECT_NE(cipher->update, nullptr);
435     EXPECT_NE(cipher->doFinal, nullptr);
436     HcfObjDestroy(cipher);
437 }
438 
439 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest240, TestSize.Level0)
440 {
441     HcfResult res = HCF_SUCCESS;
442     HcfCipher *cipher = nullptr;
443     res = HcfCipherCreate("RSA768|PKCS1", &cipher);
444     EXPECT_EQ(res, HCF_SUCCESS);
445     EXPECT_NE(cipher, nullptr);
446     EXPECT_NE(cipher->base.getClass(), nullptr);
447     EXPECT_NE(cipher->base.destroy, nullptr);
448     EXPECT_NE(cipher->init, nullptr);
449     EXPECT_NE(cipher->update, nullptr);
450     EXPECT_NE(cipher->doFinal, nullptr);
451     HcfObjDestroy(cipher);
452 }
453 
454 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest250, TestSize.Level0)
455 {
456     HcfResult res = HCF_SUCCESS;
457     HcfCipher *cipher = nullptr;
458     res = HcfCipherCreate("RSA2048|PKCS1", &cipher);
459     EXPECT_EQ(res, HCF_SUCCESS);
460     EXPECT_NE(cipher, nullptr);
461     EXPECT_NE(cipher->base.getClass(), nullptr);
462     EXPECT_NE(cipher->base.destroy, nullptr);
463     EXPECT_NE(cipher->init, nullptr);
464     EXPECT_NE(cipher->update, nullptr);
465     EXPECT_NE(cipher->doFinal, nullptr);
466     HcfObjDestroy(cipher);
467 }
468 
469 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest260, TestSize.Level0)
470 {
471     HcfResult res = HCF_SUCCESS;
472     HcfCipher *cipher = nullptr;
473     res = HcfCipherCreate("RSA512|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
474     EXPECT_EQ(res, HCF_SUCCESS);
475     EXPECT_NE(cipher, nullptr);
476     EXPECT_NE(cipher->base.getClass(), nullptr);
477     EXPECT_NE(cipher->base.destroy, nullptr);
478     EXPECT_NE(cipher->init, nullptr);
479     EXPECT_NE(cipher->update, nullptr);
480     EXPECT_NE(cipher->doFinal, nullptr);
481     HcfObjDestroy(cipher);
482 }
483 
484 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest270, TestSize.Level0)
485 {
486     HcfResult res = HCF_SUCCESS;
487     HcfCipher *cipher = nullptr;
488     res = HcfCipherCreate("RSA768|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
489     EXPECT_EQ(res, HCF_SUCCESS);
490     EXPECT_NE(cipher, nullptr);
491     EXPECT_NE(cipher->base.getClass(), nullptr);
492     EXPECT_NE(cipher->base.destroy, nullptr);
493     EXPECT_NE(cipher->init, nullptr);
494     EXPECT_NE(cipher->update, nullptr);
495     EXPECT_NE(cipher->doFinal, nullptr);
496     HcfObjDestroy(cipher);
497 }
498 
499 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest280, TestSize.Level0)
500 {
501     HcfResult res = HCF_SUCCESS;
502     HcfCipher *cipher = nullptr;
503     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
504     EXPECT_EQ(res, HCF_SUCCESS);
505     EXPECT_NE(cipher, nullptr);
506     EXPECT_NE(cipher->base.getClass(), nullptr);
507     EXPECT_NE(cipher->base.destroy, nullptr);
508     EXPECT_NE(cipher->init, nullptr);
509     EXPECT_NE(cipher->update, nullptr);
510     EXPECT_NE(cipher->doFinal, nullptr);
511     HcfObjDestroy(cipher);
512 }
513 
514 // HcfCipherCreate Incorrect case
515 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest300, TestSize.Level0)
516 {
517     HcfResult res = HCF_SUCCESS;
518     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", nullptr);
519     EXPECT_NE(res, HCF_SUCCESS);
520 }
521 
522 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest310, TestSize.Level0)
523 {
524     HcfResult res = HCF_SUCCESS;
525     HcfCipher *cipher = nullptr;
526     res = HcfCipherCreate(nullptr, &cipher);
527     EXPECT_NE(res, HCF_SUCCESS);
528     EXPECT_EQ(cipher, nullptr);
529 }
530 
531 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest320, TestSize.Level0)
532 {
533     HcfResult res = HCF_SUCCESS;
534     HcfCipher *cipher = nullptr;
535     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256|2111111111111111111111111111111111111111111111"
536         "111111111111123123", &cipher);
537     EXPECT_NE(res, HCF_SUCCESS);
538     EXPECT_EQ(cipher, nullptr);
539 }
540 
541 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest330, TestSize.Level0)
542 {
543     HcfResult res = HCF_SUCCESS;
544     HcfCipher *cipher = nullptr;
545     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA333", &cipher);
546     EXPECT_NE(res, HCF_SUCCESS);
547     EXPECT_EQ(cipher, nullptr);
548 }
549 
550 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest340, TestSize.Level0)
551 {
552     HcfResult res = HCF_SUCCESS;
553     HcfCipher *cipher = nullptr;
554     res = HcfCipherCreate("RSA2048|PKCS1_OAEP111|SHA256|MGF1_SHA333", &cipher);
555     EXPECT_NE(res, HCF_SUCCESS);
556     EXPECT_EQ(cipher, nullptr);
557 }
558 
559 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest350, TestSize.Level0)
560 {
561     HcfResult res = HCF_SUCCESS;
562     HcfCipher *cipher = nullptr;
563     res = HcfCipherCreate("RSA2111048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
564     EXPECT_NE(res, HCF_SUCCESS);
565     EXPECT_EQ(cipher, nullptr);
566 }
567 
568 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest360, TestSize.Level0)
569 {
570     HcfResult res = HCF_SUCCESS;
571     HcfCipher *cipher = nullptr;
572     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256111|MGF1_SHA256", &cipher);
573     EXPECT_NE(res, HCF_SUCCESS);
574     EXPECT_EQ(cipher, nullptr);
575 }
576 
577 // Create Cipher without padding
578 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest370, TestSize.Level0)
579 {
580     HcfResult res = HCF_SUCCESS;
581     HcfCipher *cipher = nullptr;
582     res = HcfCipherCreate("RSA2048", &cipher);
583     EXPECT_NE(res, HCF_SUCCESS);
584 }
585 
586 // destroyCipher
587 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest400, TestSize.Level0)
588 {
589     HcfResult res = HCF_SUCCESS;
590     HcfCipher *cipher = nullptr;
591     res = HcfCipherCreate("RSA2048|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
592     EXPECT_EQ(res, HCF_SUCCESS);
593     EXPECT_NE(cipher, nullptr);
594     HcfObjDestroy(cipher);
595     cipher = nullptr;
596     HcfObjDestroy(cipher);
597 }
598 
599 // init correct case
600 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest500, TestSize.Level0)
601 {
602     HcfResult res = HCF_SUCCESS;
603     HcfAsyKeyGenerator *generator = nullptr;
604     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
605     EXPECT_EQ(res, HCF_SUCCESS);
606     HcfKeyPair *keyPair = nullptr;
607     res = generator->generateKeyPair(generator, nullptr, &keyPair);
608     EXPECT_EQ(res, HCF_SUCCESS);
609 
610     HcfCipher *cipher = nullptr;
611     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
612     EXPECT_EQ(res, HCF_SUCCESS);
613     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
614     EXPECT_EQ(res, HCF_SUCCESS);
615 
616     HcfObjDestroy(keyPair);
617     HcfObjDestroy(generator);
618     HcfObjDestroy(cipher);
619 }
620 
621 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest501, TestSize.Level0)
622 {
623     HcfResult res = HCF_SUCCESS;
624     HcfAsyKeyGenerator *generator = nullptr;
625     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
626     EXPECT_EQ(res, HCF_SUCCESS);
627     HcfKeyPair *keyPair = nullptr;
628     res = generator->generateKeyPair(generator, nullptr, &keyPair);
629     EXPECT_EQ(res, HCF_SUCCESS);
630 
631     HcfCipher *cipher = nullptr;
632     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
633     EXPECT_EQ(res, HCF_SUCCESS);
634     res = cipher->init(cipher, (enum HcfCryptoMode)123, (HcfKey *)keyPair->pubKey, nullptr);
635     EXPECT_NE(res, HCF_SUCCESS);
636 
637     HcfObjDestroy(keyPair);
638     HcfObjDestroy(generator);
639     HcfObjDestroy(cipher);
640 }
641 
642 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest510, TestSize.Level0)
643 {
644     HcfResult res = HCF_SUCCESS;
645     HcfAsyKeyGenerator *generator = nullptr;
646     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
647     EXPECT_EQ(res, HCF_SUCCESS);
648     HcfKeyPair *keyPair = nullptr;
649     res = generator->generateKeyPair(generator, nullptr, &keyPair);
650     EXPECT_EQ(res, HCF_SUCCESS);
651 
652     HcfCipher *cipher = nullptr;
653     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
654     EXPECT_EQ(res, HCF_SUCCESS);
655     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
656     EXPECT_EQ(res, HCF_SUCCESS);
657 
658     HcfObjDestroy(keyPair);
659     HcfObjDestroy(generator);
660     HcfObjDestroy(cipher);
661 }
662 
663 // init incorrect case
664 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest600, TestSize.Level0)
665 {
666     HcfResult res = HCF_SUCCESS;
667     HcfAsyKeyGenerator *generator = nullptr;
668     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
669     EXPECT_EQ(res, HCF_SUCCESS);
670     HcfKeyPair *keyPair = nullptr;
671     res = generator->generateKeyPair(generator, nullptr, &keyPair);
672     EXPECT_EQ(res, HCF_SUCCESS);
673 
674     HcfCipher *cipher = nullptr;
675     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
676     EXPECT_EQ(res, HCF_SUCCESS);
677     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
678     EXPECT_NE(res, HCF_SUCCESS);
679 
680     HcfObjDestroy(keyPair);
681     HcfObjDestroy(generator);
682     HcfObjDestroy(cipher);
683 }
684 
685 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest610, TestSize.Level0)
686 {
687     HcfResult res = HCF_SUCCESS;
688     HcfAsyKeyGenerator *generator = nullptr;
689     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
690     EXPECT_EQ(res, HCF_SUCCESS);
691     HcfKeyPair *keyPair = nullptr;
692     res = generator->generateKeyPair(generator, nullptr, &keyPair);
693     EXPECT_EQ(res, HCF_SUCCESS);
694 
695     HcfCipher *cipher = nullptr;
696     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
697     EXPECT_EQ(res, HCF_SUCCESS);
698     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
699     EXPECT_NE(res, HCF_SUCCESS);
700 
701     HcfObjDestroy(keyPair);
702     HcfObjDestroy(generator);
703     HcfObjDestroy(cipher);
704 }
705 
706 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest620, TestSize.Level0)
707 {
708     HcfResult res = HCF_SUCCESS;
709     HcfAsyKeyGenerator *generator = nullptr;
710     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
711     EXPECT_EQ(res, HCF_SUCCESS);
712     HcfKeyPair *keyPair = nullptr;
713     res = generator->generateKeyPair(generator, nullptr, &keyPair);
714     EXPECT_EQ(res, HCF_SUCCESS);
715 
716     HcfCipher *cipher = nullptr;
717     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
718     EXPECT_EQ(res, HCF_SUCCESS);
719     res = cipher->init(nullptr, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
720     EXPECT_NE(res, HCF_SUCCESS);
721 
722     HcfObjDestroy(keyPair);
723     HcfObjDestroy(generator);
724     HcfObjDestroy(cipher);
725 }
726 
727 // incorrect case: use diff class, we ignore it in this version
728 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest630, TestSize.Level0)
729 {
730     HcfResult res = HCF_SUCCESS;
731     HcfAsyKeyGenerator *generator = nullptr;
732     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
733     EXPECT_EQ(res, HCF_SUCCESS);
734     HcfKeyPair *keyPair = nullptr;
735     res = generator->generateKeyPair(generator, nullptr, &keyPair);
736     EXPECT_EQ(res, HCF_SUCCESS);
737 
738     HcfCipher *aesCipher = nullptr;
739     res = HcfCipherCreate("AES128|ECB|PKCS7", &aesCipher);
740     EXPECT_EQ(res, HCF_SUCCESS);
741 
742     HcfCipher *cipher = nullptr;
743     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
744     EXPECT_EQ(res, HCF_SUCCESS);
745     res = cipher->init(aesCipher, DECRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
746     EXPECT_NE(res, HCF_SUCCESS);
747 
748     HcfObjDestroy(keyPair);
749     HcfObjDestroy(generator);
750     HcfObjDestroy(cipher);
751     HcfObjDestroy(aesCipher);
752 }
753 
754 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest640, TestSize.Level0)
755 {
756     HcfResult res = HCF_SUCCESS;
757     HcfCipher *cipher = nullptr;
758     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
759     EXPECT_EQ(res, HCF_SUCCESS);
760     res = cipher->init(cipher, DECRYPT_MODE, nullptr, nullptr);
761     EXPECT_NE(res, HCF_SUCCESS);
762     HcfObjDestroy(cipher);
763 }
764 
765 // correct case: update not support
766 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest700, TestSize.Level0)
767 {
768     uint8_t plan[] = "this is rsa cipher test!\0";
769     HcfResult res = HCF_SUCCESS;
770     HcfAsyKeyGenerator *generator = nullptr;
771     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
772     EXPECT_EQ(res, HCF_SUCCESS);
773     HcfKeyPair *keyPair = nullptr;
774     res = generator->generateKeyPair(generator, nullptr, &keyPair);
775     EXPECT_EQ(res, HCF_SUCCESS);
776 
777     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
778     HcfBlob encoutput = {.data = nullptr, .len = 0};
779     HcfCipher *cipher = nullptr;
780     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
781     EXPECT_EQ(res, HCF_SUCCESS);
782     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
783     EXPECT_EQ(res, HCF_SUCCESS);
784     res = cipher->update(cipher, &input, &encoutput);
785     EXPECT_NE(res, HCF_SUCCESS);
786     EXPECT_EQ(encoutput.data, nullptr);
787 
788     HcfObjDestroy(keyPair);
789     HcfObjDestroy(generator);
790     HcfObjDestroy(cipher);
791 }
792 
793 // dofinal correct case
794 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest800, TestSize.Level0)
795 {
796     HcfResult res = HCF_SUCCESS;
797     uint8_t plan[] = "this is rsa cipher test!\0";
798     HcfAsyKeyGenerator *generator = nullptr;
799     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
800     EXPECT_EQ(res, HCF_SUCCESS);
801     HcfKeyPair *keyPair = nullptr;
802     res = generator->generateKeyPair(generator, nullptr, &keyPair);
803     EXPECT_EQ(res, HCF_SUCCESS);
804     EXPECT_NE(keyPair, nullptr);
805     EXPECT_NE(keyPair->priKey, nullptr);
806     EXPECT_NE(keyPair->pubKey, nullptr);
807 
808     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
809     HcfBlob encoutput = {.data = nullptr, .len = 0};
810     HcfCipher *cipher = nullptr;
811     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
812     EXPECT_EQ(res, HCF_SUCCESS);
813 
814     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
815     EXPECT_EQ(res, HCF_SUCCESS);
816     res = cipher->doFinal(cipher, &input, &encoutput);
817     EXPECT_EQ(res, HCF_SUCCESS);
818     HcfObjDestroy(cipher);
819 
820     HcfBlob decoutput = {.data = nullptr, .len = 0};
821     cipher = nullptr;
822     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
823     EXPECT_EQ(res, HCF_SUCCESS);
824     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
825     EXPECT_EQ(res, HCF_SUCCESS);
826     res = cipher->doFinal(cipher, &encoutput, &decoutput);
827     EXPECT_EQ(res, HCF_SUCCESS);
828     HcfObjDestroy(cipher);
829     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
830 
831     HcfFree(encoutput.data);
832     HcfFree(decoutput.data);
833 
834     HcfObjDestroy(keyPair);
835     HcfObjDestroy(generator);
836 }
837 
838 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest810, TestSize.Level0)
839 {
840     HcfResult res = HCF_SUCCESS;
841     uint8_t plan[] = "this is rsa cipher test!\0";
842     HcfAsyKeyGenerator *generator = nullptr;
843     res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_3", &generator);
844     EXPECT_EQ(res, HCF_SUCCESS);
845     HcfKeyPair *keyPair = nullptr;
846     res = generator->generateKeyPair(generator, nullptr, &keyPair);
847     EXPECT_EQ(res, HCF_SUCCESS);
848     EXPECT_NE(keyPair, nullptr);
849     EXPECT_NE(keyPair->priKey, nullptr);
850     EXPECT_NE(keyPair->pubKey, nullptr);
851 
852     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
853     HcfBlob encoutput = {.data = nullptr, .len = 0};
854     HcfCipher *cipher = nullptr;
855     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
856     EXPECT_EQ(res, HCF_SUCCESS);
857 
858     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
859     EXPECT_EQ(res, HCF_SUCCESS);
860     res = cipher->doFinal(cipher, &input, &encoutput);
861     EXPECT_EQ(res, HCF_SUCCESS);
862     HcfObjDestroy(cipher);
863 
864     HcfBlob decoutput = {.data = nullptr, .len = 0};
865     cipher = nullptr;
866     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
867     EXPECT_EQ(res, HCF_SUCCESS);
868     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
869     EXPECT_EQ(res, HCF_SUCCESS);
870     res = cipher->doFinal(cipher, &encoutput, &decoutput);
871     EXPECT_EQ(res, HCF_SUCCESS);
872     HcfObjDestroy(cipher);
873     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
874 
875     HcfFree(encoutput.data);
876     HcfFree(decoutput.data);
877 
878     HcfObjDestroy(keyPair);
879     HcfObjDestroy(generator);
880 }
881 
882 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest820, TestSize.Level0)
883 {
884     HcfResult res = HCF_SUCCESS;
885     uint8_t plan[] = "this is rsa cipher test!\0";
886     HcfAsyKeyGenerator *generator = nullptr;
887     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
888 
889     HcfKeyPair *keyPair = nullptr;
890     res = generator->generateKeyPair(generator, nullptr, &keyPair);
891     EXPECT_EQ(res, HCF_SUCCESS);
892     EXPECT_NE(keyPair, nullptr);
893     EXPECT_NE(keyPair->priKey, nullptr);
894     EXPECT_NE(keyPair->pubKey, nullptr);
895 
896     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
897     HcfBlob encoutput = {.data = nullptr, .len = 0};
898     HcfCipher *cipher = nullptr;
899     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
900     EXPECT_EQ(res, HCF_SUCCESS);
901 
902     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
903     EXPECT_EQ(res, HCF_SUCCESS);
904     res = cipher->doFinal(cipher, &input, &encoutput);
905     EXPECT_EQ(res, HCF_SUCCESS);
906     HcfObjDestroy(cipher);
907 
908     HcfBlob decoutput = {.data = nullptr, .len = 0};
909     cipher = nullptr;
910     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
911     EXPECT_EQ(res, HCF_SUCCESS);
912     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
913     EXPECT_EQ(res, HCF_SUCCESS);
914     res = cipher->doFinal(cipher, &encoutput, &decoutput);
915     EXPECT_EQ(res, HCF_SUCCESS);
916     HcfObjDestroy(cipher);
917     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
918 
919     HcfFree(encoutput.data);
920     HcfFree(decoutput.data);
921 
922     HcfObjDestroy(keyPair);
923     HcfObjDestroy(generator);
924 }
925 
926 // incorrect case: algName out of boundary
927 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest830, TestSize.Level0)
928 {
929     HcfResult res = HCF_SUCCESS;
930     uint8_t plan[] = "this is rsa cipher test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
931         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!\0";
932     HcfAsyKeyGenerator *generator = nullptr;
933     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
934 
935     HcfKeyPair *keyPair = nullptr;
936     res = generator->generateKeyPair(generator, nullptr, &keyPair);
937     EXPECT_EQ(res, HCF_SUCCESS);
938     EXPECT_NE(keyPair, nullptr);
939     EXPECT_NE(keyPair->priKey, nullptr);
940     EXPECT_NE(keyPair->pubKey, nullptr);
941 
942     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
943     HcfBlob encoutput = {.data = nullptr, .len = 0};
944     HcfCipher *cipher = nullptr;
945     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
946     EXPECT_EQ(res, HCF_SUCCESS);
947 
948     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
949     EXPECT_EQ(res, HCF_SUCCESS);
950     res = cipher->doFinal(cipher, &input, &encoutput);
951     EXPECT_NE(res, HCF_SUCCESS);
952     HcfObjDestroy(cipher);
953 
954     HcfBlob decoutput = {.data = nullptr, .len = 0};
955     cipher = nullptr;
956     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
957     EXPECT_EQ(res, HCF_SUCCESS);
958     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
959     EXPECT_EQ(res, HCF_SUCCESS);
960     res = cipher->doFinal(cipher, &encoutput, &decoutput);
961     EXPECT_NE(res, HCF_SUCCESS);
962     HcfObjDestroy(cipher);
963     EXPECT_STRNE((char *)plan, (char *)decoutput.data);
964 
965     HcfFree(encoutput.data);
966     HcfFree(decoutput.data);
967 
968     HcfObjDestroy(keyPair);
969     HcfObjDestroy(generator);
970 }
971 
972 
973 // Incorrect case: use OAEP pading without mgf1md
974 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest840, TestSize.Level0)
975 {
976     HcfResult res = HCF_SUCCESS;
977 
978     HcfAsyKeyGenerator *generator = nullptr;
979     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
980 
981     HcfKeyPair *keyPair = nullptr;
982     res = generator->generateKeyPair(generator, nullptr, &keyPair);
983     HcfObjDestroy(generator);
984     HcfObjDestroy(keyPair);
985 
986     HcfCipher *cipher = nullptr;
987     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256", &cipher);
988     EXPECT_NE(res, HCF_SUCCESS);
989     EXPECT_EQ(cipher, nullptr);
990 }
991 
992 // Incorrect case: use OAEP pading without md
993 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest845, TestSize.Level0)
994 {
995     HcfResult res = HCF_SUCCESS;
996 
997     HcfAsyKeyGenerator *generator = nullptr;
998     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
999 
1000     HcfKeyPair *keyPair = nullptr;
1001     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1002     HcfObjDestroy(generator);
1003     HcfObjDestroy(keyPair);
1004 
1005     HcfCipher *cipher = nullptr;
1006     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|MGF1_SHA256", &cipher);
1007     EXPECT_NE(res, HCF_SUCCESS);
1008     EXPECT_EQ(cipher, nullptr);
1009 }
1010 
1011 // Correct case: test genEncoded and convert key
1012 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest850, TestSize.Level0)
1013 {
1014     uint8_t plan[] = "this is rsa cipher test!\0";
1015     HcfAsyKeyGenerator *generator = nullptr;
1016     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1017     EXPECT_EQ(res, HCF_SUCCESS);
1018     EXPECT_NE(generator, nullptr);
1019 
1020     HcfKeyPair *keyPair = nullptr;
1021     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1022     EXPECT_EQ(res, HCF_SUCCESS);
1023     HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
1024     HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1025     res = keyPair->pubKey->base.getEncoded((HcfKey *)keyPair->pubKey, &pubKeyBlob);
1026     EXPECT_EQ(res, HCF_SUCCESS);
1027     res = keyPair->priKey->base.getEncoded((HcfKey *)keyPair->priKey, &priKeyBlob);
1028     EXPECT_EQ(res, HCF_SUCCESS);
1029 
1030     HcfKeyPair *dupKeyPair = nullptr;
1031     res = generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
1032     EXPECT_EQ(res, HCF_SUCCESS);
1033 
1034     HcfObjDestroy(generator);
1035     HcfObjDestroy(keyPair);
1036 
1037     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1038     HcfBlob encoutput = {.data = nullptr, .len = 0};
1039     HcfCipher *cipher = nullptr;
1040     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1041     EXPECT_EQ(res, HCF_SUCCESS);
1042 
1043     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)dupKeyPair->pubKey, nullptr);
1044     EXPECT_EQ(res, HCF_SUCCESS);
1045     res = cipher->doFinal(cipher, &input, &encoutput);
1046     EXPECT_EQ(res, HCF_SUCCESS);
1047     HcfObjDestroy(cipher);
1048 
1049     HcfBlob decoutput = {.data = nullptr, .len = 0};
1050     cipher = nullptr;
1051     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1052     EXPECT_EQ(res, HCF_SUCCESS);
1053     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)dupKeyPair->priKey, nullptr);
1054     EXPECT_EQ(res, HCF_SUCCESS);
1055     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1056     EXPECT_EQ(res, HCF_SUCCESS);
1057     HcfObjDestroy(cipher);
1058     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1059 
1060     HcfFree(encoutput.data);
1061     HcfFree(decoutput.data);
1062     HcfFree(pubKeyBlob.data);
1063     HcfFree(priKeyBlob.data);
1064     HcfObjDestroy(dupKeyPair);
1065 }
1066 
1067 // correct case: test OAEP Plaintext boundary:
1068 // RSA_size - (md_result_len * mgf1md_result_len) - 2 = 128 - (32 + 32) - 2 = 62
1069 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest860, TestSize.Level0)
1070 {
1071     HcfResult res = HCF_SUCCESS;
1072     uint8_t plan1[] = "00112233445566778899aabbccddeeff0aaaaaaaaaaaaaaaaaaaaaaaaaa";
1073     uint8_t plan2[] = "00112233445566778899aabbccddeeffaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
1074     uint8_t plan3[] = "00112233445566778899aabbccddeeff00112233445566778899aaaaaaaaaa";
1075     HcfAsyKeyGenerator *generator = nullptr;
1076     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1077 
1078     HcfKeyPair *keyPair = nullptr;
1079     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1080     EXPECT_EQ(res, HCF_SUCCESS);
1081     EXPECT_NE(keyPair, nullptr);
1082     EXPECT_NE(keyPair->priKey, nullptr);
1083     EXPECT_NE(keyPair->pubKey, nullptr);
1084 
1085     HcfCipher *cipher = nullptr;
1086     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1087     EXPECT_EQ(res, HCF_SUCCESS);
1088 
1089     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1090     EXPECT_EQ(res, HCF_SUCCESS);
1091 
1092     HcfBlob encoutput1 = {.data = nullptr, .len = 0};
1093     HcfBlob encoutput2 = {.data = nullptr, .len = 0};
1094     HcfBlob encoutput3 = {.data = nullptr, .len = 0};
1095     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
1096     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
1097     HcfBlob input3 = {.data = (uint8_t *)plan3, .len = strlen((char *)plan3)};
1098     res = cipher->doFinal(cipher, &input1, &encoutput1);
1099     EXPECT_EQ(res, HCF_SUCCESS);
1100     res = cipher->doFinal(cipher, &input2, &encoutput2);
1101     EXPECT_NE(res, HCF_SUCCESS);
1102     res = cipher->doFinal(cipher, &input3, &encoutput2);
1103     EXPECT_EQ(res, HCF_SUCCESS);
1104 
1105 
1106     HcfObjDestroy(cipher);
1107     HcfFree(encoutput1.data);
1108     HcfFree(encoutput2.data);
1109     HcfFree(encoutput3.data);
1110     HcfObjDestroy(keyPair);
1111     HcfObjDestroy(generator);
1112 }
1113 
1114 // correct case: test nopadding boundary < RSA_size(rsa)
1115 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest870, TestSize.Level0)
1116 {
1117     HcfResult res = HCF_SUCCESS;
1118     uint8_t plan1[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1119         "1122334455111111111116";
1120     uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1121         "112233445511111111111611111111111";
1122 
1123     HcfAsyKeyGenerator *generator = nullptr;
1124     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1125 
1126     HcfKeyPair *keyPair = nullptr;
1127     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1128     EXPECT_EQ(res, HCF_SUCCESS);
1129     EXPECT_NE(keyPair, nullptr);
1130     EXPECT_NE(keyPair->priKey, nullptr);
1131     EXPECT_NE(keyPair->pubKey, nullptr);
1132 
1133     HcfCipher *cipher = nullptr;
1134     res = HcfCipherCreate("RSA1024|NoPadding", &cipher);
1135     EXPECT_EQ(res, HCF_SUCCESS);
1136 
1137     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1138     EXPECT_EQ(res, HCF_SUCCESS);
1139 
1140 
1141     HcfBlob encoutput1 = {.data = nullptr, .len = 0};
1142     HcfBlob encoutput2 = {.data = nullptr, .len = 0};
1143 
1144     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
1145     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
1146 
1147     res = cipher->doFinal(cipher, &input1, &encoutput1);
1148     EXPECT_NE(res, HCF_SUCCESS);
1149     res = cipher->doFinal(cipher, &input2, &encoutput2);
1150     EXPECT_EQ(res, HCF_SUCCESS);
1151 
1152     HcfObjDestroy(cipher);
1153     HcfFree(encoutput1.data);
1154     HcfFree(encoutput2.data);
1155     HcfObjDestroy(keyPair);
1156     HcfObjDestroy(generator);
1157 }
1158 
1159 // correct case: test PKCS1 boundary < RSA_size(rsa) - 11
1160 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest880, TestSize.Level0)
1161 {
1162     HcfResult res = HCF_SUCCESS;
1163     uint8_t plan1[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1164         "1122334455111111111116";
1165     uint8_t plan2[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeffasdasdbccddeeff0011223344556600"
1166         "11223344551111111111161";
1167 
1168     HcfAsyKeyGenerator *generator = nullptr;
1169     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1170 
1171     HcfKeyPair *keyPair = nullptr;
1172     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1173     EXPECT_EQ(res, HCF_SUCCESS);
1174     EXPECT_NE(keyPair, nullptr);
1175     EXPECT_NE(keyPair->priKey, nullptr);
1176     EXPECT_NE(keyPair->pubKey, nullptr);
1177 
1178     HcfCipher *cipher = nullptr;
1179     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1180     EXPECT_EQ(res, HCF_SUCCESS);
1181 
1182     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1183     EXPECT_EQ(res, HCF_SUCCESS);
1184 
1185     HcfBlob encoutput1 = {.data = nullptr, .len = 0};
1186     HcfBlob encoutput2 = {.data = nullptr, .len = 0};
1187 
1188     HcfBlob input1 = {.data = (uint8_t *)plan1, .len = strlen((char *)plan1)};
1189     HcfBlob input2 = {.data = (uint8_t *)plan2, .len = strlen((char *)plan2)};
1190 
1191     res = cipher->doFinal(cipher, &input1, &encoutput1);
1192     EXPECT_EQ(res, HCF_SUCCESS);
1193     res = cipher->doFinal(cipher, &input2, &encoutput2);
1194     EXPECT_NE(res, HCF_SUCCESS);
1195 
1196     HcfObjDestroy(cipher);
1197     HcfFree(encoutput1.data);
1198     HcfFree(encoutput2.data);
1199     HcfObjDestroy(keyPair);
1200     HcfObjDestroy(generator);
1201 }
1202 
1203 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest890, TestSize.Level0)
1204 {
1205     HcfResult res = HCF_SUCCESS;
1206     HcfAsyKeyGenerator *generator = nullptr;
1207     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1208     EXPECT_EQ(res, HCF_SUCCESS);
1209 
1210     HcfKeyPair *keyPair = nullptr;
1211     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1212     HcfCipher *cipher = nullptr;
1213     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1214     EXPECT_EQ(res, HCF_SUCCESS);
1215 
1216     res = cipher->init((HcfCipher *)generator, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1217     EXPECT_NE(res, HCF_SUCCESS);
1218 
1219     HcfObjDestroy(generator);
1220     HcfObjDestroy(cipher);
1221     HcfObjDestroy(keyPair);
1222 }
1223 
1224 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest900, TestSize.Level0)
1225 {
1226     HcfResult res = HCF_SUCCESS;
1227     HcfAsyKeyGenerator *generator = nullptr;
1228     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1229     HcfKeyPair *keyPair = nullptr;
1230     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1231     EXPECT_EQ(res, HCF_SUCCESS);
1232     EXPECT_NE(keyPair, nullptr);
1233     EXPECT_NE(keyPair->priKey, nullptr);
1234     EXPECT_NE(keyPair->pubKey, nullptr);
1235 
1236     HcfCipher *cipher = nullptr;
1237     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1238     EXPECT_EQ(res, HCF_SUCCESS);
1239 
1240     uint8_t plan[] = "12312123123";
1241     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1242 
1243     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1244     EXPECT_EQ(res, HCF_SUCCESS);
1245 
1246     res = cipher->doFinal(cipher, &input, nullptr);
1247     EXPECT_NE(res, HCF_SUCCESS);
1248 
1249     HcfObjDestroy(keyPair);
1250     HcfObjDestroy(generator);
1251     HcfObjDestroy(cipher);
1252 }
1253 
1254 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest910, TestSize.Level0)
1255 {
1256     HcfResult res = HCF_SUCCESS;
1257     HcfAsyKeyGenerator *generator = nullptr;
1258     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1259     HcfKeyPair *keyPair = nullptr;
1260     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1261     EXPECT_EQ(res, HCF_SUCCESS);
1262     EXPECT_NE(keyPair, nullptr);
1263     EXPECT_NE(keyPair->priKey, nullptr);
1264     EXPECT_NE(keyPair->pubKey, nullptr);
1265 
1266     HcfCipher *cipher = nullptr;
1267     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1268     EXPECT_EQ(res, HCF_SUCCESS);
1269 
1270     uint8_t plan[] = "12312123123";
1271     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1272 
1273     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1274     EXPECT_EQ(res, HCF_SUCCESS);
1275 
1276     HcfBlob blob;
1277     res = cipher->doFinal((HcfCipher *)generator, &input, &blob);
1278     EXPECT_NE(res, HCF_SUCCESS);
1279 
1280     HcfObjDestroy(keyPair);
1281     HcfObjDestroy(generator);
1282     HcfObjDestroy(cipher);
1283 }
1284 
1285 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest920, TestSize.Level0)
1286 {
1287     HcfResult res = HCF_SUCCESS;
1288     HcfCipher *cipher = nullptr;
1289     res = HcfCipherCreate("RSA10|PK1", &cipher);
1290     EXPECT_NE(res, HCF_SUCCESS);
1291 }
1292 
1293 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest930, TestSize.Level0)
1294 {
1295     HcfResult res = HCF_SUCCESS;
1296     HcfCipher *cipher = nullptr;
1297     res = HcfCipherCreate("RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|"
1298         "RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1|RSA1024|PKCS1", &cipher);
1299     EXPECT_NE(res, HCF_SUCCESS);
1300 }
1301 
1302 // incorrect : init Cipher twice
1303 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest940, TestSize.Level0)
1304 {
1305     HcfResult res = HCF_SUCCESS;
1306     HcfAsyKeyGenerator *generator = nullptr;
1307     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1308     EXPECT_EQ(res, HCF_SUCCESS);
1309     HcfKeyPair *keyPair = nullptr;
1310     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1311     EXPECT_EQ(res, HCF_SUCCESS);
1312 
1313     HcfCipher *cipher = nullptr;
1314     res = HcfCipherCreate("RSA1024|PKCS1", &cipher);
1315     EXPECT_EQ(res, HCF_SUCCESS);
1316     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1317     EXPECT_EQ(res, HCF_SUCCESS);
1318     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1319     EXPECT_NE(res, HCF_SUCCESS);
1320 
1321     HcfObjDestroy(keyPair);
1322     HcfObjDestroy(generator);
1323     HcfObjDestroy(cipher);
1324 }
1325 
1326 // correct: test oaep pSource normal.
1327 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest001, TestSize.Level0)
1328 {
1329     uint8_t plan[] = "this is rsa cipher test!\0";
1330     HcfAsyKeyGenerator *generator = nullptr;
1331     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
1332 
1333     HcfKeyPair *keyPair = nullptr;
1334     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1335     EXPECT_EQ(res, HCF_SUCCESS);
1336     EXPECT_NE(keyPair, nullptr);
1337     EXPECT_NE(keyPair->priKey, nullptr);
1338     EXPECT_NE(keyPair->pubKey, nullptr);
1339 
1340     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1341     HcfBlob encoutput = {.data = nullptr, .len = 0};
1342     HcfCipher *cipher = nullptr;
1343     // remove 1024
1344     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1345     EXPECT_EQ(res, HCF_SUCCESS);
1346 
1347     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1348     EXPECT_EQ(res, HCF_SUCCESS);
1349     res = RsaCipherSpec(cipher);
1350     EXPECT_EQ(res, HCF_SUCCESS);
1351     res = cipher->doFinal(cipher, &input, &encoutput);
1352     EXPECT_EQ(res, HCF_SUCCESS);
1353     HcfObjDestroy(cipher);
1354 
1355     // decrypt
1356     HcfBlob decoutput = {.data = nullptr, .len = 0};
1357     cipher = nullptr;
1358     // has1024
1359     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1360     EXPECT_EQ(res, HCF_SUCCESS);
1361 
1362     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1363     EXPECT_EQ(res, HCF_SUCCESS);
1364 
1365     res = RsaCipherSpec(cipher);
1366     EXPECT_EQ(res, HCF_SUCCESS);
1367 
1368     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1369     EXPECT_EQ(res, HCF_SUCCESS);
1370     HcfObjDestroy(cipher);
1371 
1372     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1373 
1374     HcfFree(encoutput.data);
1375     HcfFree(decoutput.data);
1376 
1377     HcfObjDestroy(keyPair);
1378     HcfObjDestroy(generator);
1379 }
1380 
1381 // test cipher by key generated by spec and set & get func after init.
1382 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest002, TestSize.Level0)
1383 {
1384     uint8_t plan[] = "this is rsa cipher test!\0";
1385     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1386     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1387     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1388     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1389     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1390 
1391     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1392     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1393     EXPECT_EQ(res, HCF_SUCCESS);
1394     EXPECT_NE(generator, nullptr);
1395 
1396     HcfKeyPair *keyPair = nullptr;
1397     // generator key type from generator's spec
1398     res = generator->generateKeyPair(generator, &keyPair);
1399     EXPECT_EQ(res, HCF_SUCCESS);
1400     EXPECT_NE(keyPair, nullptr);
1401 
1402     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1403     HcfBlob encoutput = {.data = nullptr, .len = 0};
1404     HcfCipher *cipher = nullptr;
1405     // remove 1024
1406     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1407     EXPECT_EQ(res, HCF_SUCCESS);
1408 
1409     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1410     EXPECT_EQ(res, HCF_SUCCESS);
1411     res = RsaCipherSpec(cipher);
1412     EXPECT_EQ(res, HCF_SUCCESS);
1413     res = cipher->doFinal(cipher, &input, &encoutput);
1414     EXPECT_EQ(res, HCF_SUCCESS);
1415     HcfObjDestroy(cipher);
1416 
1417     // decrypt
1418     HcfBlob decoutput = {.data = nullptr, .len = 0};
1419     cipher = nullptr;
1420     // has1024
1421     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1422     EXPECT_EQ(res, HCF_SUCCESS);
1423 
1424     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1425     EXPECT_EQ(res, HCF_SUCCESS);
1426 
1427     res = RsaCipherSpec(cipher);
1428     EXPECT_EQ(res, HCF_SUCCESS);
1429 
1430     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1431     EXPECT_EQ(res, HCF_SUCCESS);
1432     HcfObjDestroy(cipher);
1433 
1434     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1435 
1436     HcfFree(encoutput.data);
1437     HcfFree(decoutput.data);
1438 
1439     HcfObjDestroy(keyPair);
1440     HcfObjDestroy(generator);
1441 }
1442 
1443 // test in encrypt set pSource before init and in decrypt set pSource after init.
1444 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest003, TestSize.Level0)
1445 {
1446     uint8_t plan[] = "this is rsa cipher test!\0";
1447     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1448     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1449     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1450     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1451     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1452 
1453     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1454     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1455     EXPECT_EQ(res, HCF_SUCCESS);
1456     HcfKeyPair *keyPair = nullptr;
1457     res = generator->generateKeyPair(generator, &keyPair);
1458     EXPECT_EQ(res, HCF_SUCCESS);
1459     EXPECT_NE(keyPair, nullptr);
1460 
1461     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1462     HcfBlob encoutput = {.data = nullptr, .len = 0};
1463     HcfCipher *cipher = nullptr;
1464     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1465     EXPECT_EQ(res, HCF_SUCCESS);
1466     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1467     EXPECT_EQ(res, HCF_SUCCESS);
1468 
1469     // test cipher encrypt psource set before cipher init.
1470     uint8_t pSourceData[] = "123456\0";
1471     HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1472     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
1473     EXPECT_EQ(res, HCF_SUCCESS);
1474     res = cipher->doFinal(cipher, &input, &encoutput);
1475     EXPECT_EQ(res, HCF_SUCCESS);
1476     HcfObjDestroy(cipher);
1477 
1478     // decrypt
1479     HcfBlob decoutput = {.data = nullptr, .len = 0};
1480     cipher = nullptr;
1481     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1482     EXPECT_EQ(res, HCF_SUCCESS);
1483     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1484     EXPECT_EQ(res, HCF_SUCCESS);
1485     // test cipher decrypt psource set after init
1486     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
1487     EXPECT_EQ(res, HCF_SUCCESS);
1488     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1489     EXPECT_EQ(res, HCF_SUCCESS);
1490     HcfObjDestroy(cipher);
1491 
1492     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1493 
1494     // free decrpyt spec
1495     HcfFree(encoutput.data);
1496     HcfFree(decoutput.data);
1497 
1498     HcfObjDestroy(keyPair);
1499     HcfObjDestroy(generator);
1500 }
1501 
1502 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest005, TestSize.Level0)
1503 {
1504     uint8_t plan[] = "this is rsa cipher test!\0";
1505     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1506     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1507     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1508     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1509     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1510 
1511     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1512     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1513     EXPECT_EQ(res, HCF_SUCCESS);
1514     EXPECT_NE(generator, nullptr);
1515 
1516     HcfKeyPair *keyPair = nullptr;
1517     // generator key type from generator's spec
1518     res = generator->generateKeyPair(generator, &keyPair);
1519     EXPECT_EQ(res, HCF_SUCCESS);
1520     EXPECT_NE(keyPair, nullptr);
1521 
1522     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1523     HcfBlob encoutput = {.data = nullptr, .len = 0};
1524     HcfCipher *cipher = nullptr;
1525     // remove 1024
1526     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1527     EXPECT_EQ(res, HCF_SUCCESS);
1528     res = RsaCipherSpec(cipher);
1529     EXPECT_EQ(res, HCF_SUCCESS);
1530     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1531     EXPECT_EQ(res, HCF_SUCCESS);
1532 
1533     res = cipher->doFinal(cipher, &input, &encoutput);
1534     EXPECT_EQ(res, HCF_SUCCESS);
1535     HcfObjDestroy(cipher);
1536 
1537     // decrypt
1538     HcfBlob decoutput = {.data = nullptr, .len = 0};
1539     cipher = nullptr;
1540     // has1024
1541     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1542     EXPECT_EQ(res, HCF_SUCCESS);
1543 
1544     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1545     EXPECT_EQ(res, HCF_SUCCESS);
1546 
1547     res = RsaCipherSpec(cipher);
1548     EXPECT_EQ(res, HCF_SUCCESS);
1549 
1550     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1551     EXPECT_EQ(res, HCF_SUCCESS);
1552     HcfObjDestroy(cipher);
1553 
1554     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1555 
1556     HcfFree(encoutput.data);
1557     HcfFree(decoutput.data);
1558 
1559     HcfObjDestroy(keyPair);
1560     HcfObjDestroy(generator);
1561 }
1562 
1563 // double set test
1564 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest004, TestSize.Level0)
1565 {
1566     uint8_t plan[] = "This is cipher test.\0";
1567     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1568     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1569     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1570     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1571     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1572 
1573     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1574     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1575     EXPECT_EQ(res, HCF_SUCCESS);
1576     EXPECT_NE(generator, nullptr);
1577 
1578     HcfKeyPair *keyPair = nullptr;
1579     res = generator->generateKeyPair(generator, &keyPair);
1580     EXPECT_EQ(res, HCF_SUCCESS);
1581     EXPECT_NE(keyPair, nullptr);
1582     EXPECT_NE(keyPair->priKey, nullptr);
1583     EXPECT_NE(keyPair->pubKey, nullptr);
1584 
1585     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1586     HcfBlob encoutput = {.data = nullptr, .len = 0};
1587     HcfCipher *cipher = nullptr;
1588     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1589     EXPECT_EQ(res, HCF_SUCCESS);
1590 
1591     uint8_t pSourceData[] = "123456\0";
1592     HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1593     res = RsaSpecpSource(cipher, pSourceData, pSource);
1594     EXPECT_EQ(res, HCF_SUCCESS);
1595 
1596     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1597     EXPECT_EQ(res, HCF_SUCCESS);
1598     res = cipher->doFinal(cipher, &input, &encoutput);
1599     EXPECT_EQ(res, HCF_SUCCESS);
1600     HcfObjDestroy(cipher);
1601 
1602     HcfBlob decoutput = {.data = nullptr, .len = 0};
1603     cipher = nullptr;
1604     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1605     EXPECT_EQ(res, HCF_SUCCESS);
1606     // decrypt set before init
1607     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MGF1_PSRC_UINT8ARR, pSource);
1608     EXPECT_EQ(res, HCF_SUCCESS);
1609 
1610     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1611     EXPECT_EQ(res, HCF_SUCCESS);
1612     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1613     EXPECT_EQ(res, HCF_SUCCESS);
1614     HcfObjDestroy(cipher);
1615     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1616 
1617     HcfFree(encoutput.data);
1618     HcfFree(decoutput.data);
1619 
1620     HcfObjDestroy(keyPair);
1621     HcfObjDestroy(generator);
1622 }
1623 
1624 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest007, TestSize.Level0)
1625 {
1626     uint8_t plan[] = "this is rsa cipher test!\0";
1627     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1628     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1629     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1630     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1631     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1632 
1633     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1634     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1635     EXPECT_EQ(res, HCF_SUCCESS);
1636     HcfKeyPair *keyPair = nullptr;
1637     res = generator->generateKeyPair(generator, &keyPair);
1638     EXPECT_EQ(res, HCF_SUCCESS);
1639     EXPECT_NE(keyPair, nullptr);
1640 
1641     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1642     HcfBlob encoutput = {.data = nullptr, .len = 0};
1643     HcfCipher *cipher = nullptr;
1644     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1645     EXPECT_EQ(res, HCF_SUCCESS);
1646     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1647     EXPECT_EQ(res, HCF_SUCCESS);
1648 
1649     HcfBlob pSource = { .data = nullptr, .len = 0 };
1650     // self == nullptr
1651     res = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_PSRC_UINT8ARR, pSource);
1652     EXPECT_NE(res, HCF_SUCCESS);
1653     res = cipher->doFinal(cipher, &input, &encoutput);
1654     EXPECT_EQ(res, HCF_SUCCESS);
1655     HcfObjDestroy(cipher);
1656 
1657     // decrypt
1658     HcfBlob decoutput = {.data = nullptr, .len = 0};
1659     cipher = nullptr;
1660     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1661     EXPECT_EQ(res, HCF_SUCCESS);
1662     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1663     EXPECT_EQ(res, HCF_SUCCESS);
1664     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1665     EXPECT_EQ(res, HCF_SUCCESS);
1666     HcfObjDestroy(cipher);
1667 
1668     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1669 
1670     // free decrpyt spec
1671     HcfFree(encoutput.data);
1672     HcfFree(decoutput.data);
1673 
1674     HcfObjDestroy(keyPair);
1675     HcfObjDestroy(generator);
1676 }
1677 
1678 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest008, TestSize.Level0)
1679 {
1680     uint8_t plan[] = "this is rsa cipher test!\0";
1681     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1682     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1683     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1684     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1685     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1686 
1687     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1688     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1689     EXPECT_EQ(res, HCF_SUCCESS);
1690     HcfKeyPair *keyPair = nullptr;
1691     res = generator->generateKeyPair(generator, &keyPair);
1692     EXPECT_EQ(res, HCF_SUCCESS);
1693     EXPECT_NE(keyPair, nullptr);
1694 
1695     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen((char *)plan)};
1696     HcfBlob encoutput = {.data = nullptr, .len = 0};
1697     HcfCipher *cipher = nullptr;
1698     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1699     EXPECT_EQ(res, HCF_SUCCESS);
1700     res = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)keyPair->pubKey, nullptr);
1701     EXPECT_EQ(res, HCF_SUCCESS);
1702 
1703     uint8_t pSourceData[] = "123456\0";
1704     HcfBlob pSource = {.data = (uint8_t *)pSourceData, .len = strlen((char *)pSourceData)};
1705     // enum error
1706     res = cipher->setCipherSpecUint8Array(cipher, OAEP_MD_NAME_STR, pSource);
1707     EXPECT_NE(res, HCF_SUCCESS);
1708     res = cipher->doFinal(cipher, &input, &encoutput);
1709     EXPECT_EQ(res, HCF_SUCCESS);
1710     HcfObjDestroy(cipher);
1711 
1712     // decrypt
1713     HcfBlob decoutput = {.data = nullptr, .len = 0};
1714     cipher = nullptr;
1715     res = HcfCipherCreate("RSA1024|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1716     EXPECT_EQ(res, HCF_SUCCESS);
1717     res = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)keyPair->priKey, nullptr);
1718     EXPECT_EQ(res, HCF_SUCCESS);
1719     res = cipher->doFinal(cipher, &encoutput, &decoutput);
1720     EXPECT_EQ(res, HCF_SUCCESS);
1721     HcfObjDestroy(cipher);
1722 
1723     EXPECT_STREQ((char *)plan, (char *)decoutput.data);
1724 
1725     // free decrpyt spec
1726     HcfFree(encoutput.data);
1727     HcfFree(decoutput.data);
1728 
1729     HcfObjDestroy(keyPair);
1730     HcfObjDestroy(generator);
1731 }
1732 
1733 // get func exception
1734 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest010, TestSize.Level0)
1735 {
1736     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1737     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1738     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1739     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1740     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1741 
1742     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1743     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1744     EXPECT_EQ(res, HCF_SUCCESS);
1745     HcfKeyPair *keyPair = nullptr;
1746     res = generator->generateKeyPair(generator, &keyPair);
1747     EXPECT_EQ(res, HCF_SUCCESS);
1748     EXPECT_NE(keyPair, nullptr);
1749 
1750     HcfCipher *cipher = nullptr;
1751     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1752     EXPECT_EQ(res, HCF_SUCCESS);
1753     res = cipher->getCipherSpecString(cipher, OAEP_MD_NAME_STR, nullptr);
1754     EXPECT_NE(res, HCF_SUCCESS);
1755     HcfObjDestroy(cipher);
1756 
1757     HcfObjDestroy(keyPair);
1758     HcfObjDestroy(generator);
1759 }
1760 
1761 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest011, TestSize.Level0)
1762 {
1763     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1764     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1765     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1766     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1767     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1768 
1769     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1770     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1771     EXPECT_EQ(res, HCF_SUCCESS);
1772     HcfKeyPair *keyPair = nullptr;
1773     res = generator->generateKeyPair(generator, &keyPair);
1774     EXPECT_EQ(res, HCF_SUCCESS);
1775     EXPECT_NE(keyPair, nullptr);
1776 
1777     HcfCipher *cipher = nullptr;
1778     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1779     EXPECT_EQ(res, HCF_SUCCESS);
1780     res = cipher->getCipherSpecString(nullptr, OAEP_MD_NAME_STR, nullptr);
1781     EXPECT_NE(res, HCF_SUCCESS);
1782     HcfObjDestroy(cipher);
1783 
1784     HcfObjDestroy(keyPair);
1785     HcfObjDestroy(generator);
1786 }
1787 
1788 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest012, TestSize.Level0)
1789 {
1790     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1791     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1792     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1793     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1794     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1795 
1796     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1797     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1798     EXPECT_EQ(res, HCF_SUCCESS);
1799     HcfKeyPair *keyPair = nullptr;
1800     res = generator->generateKeyPair(generator, &keyPair);
1801     EXPECT_EQ(res, HCF_SUCCESS);
1802     EXPECT_NE(keyPair, nullptr);
1803 
1804     HcfCipher *cipher = nullptr;
1805     char *ret = nullptr;
1806     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1807     EXPECT_EQ(res, HCF_SUCCESS);
1808     res = cipher->getCipherSpecString(cipher, OAEP_MGF1_PSRC_UINT8ARR, &ret);
1809     EXPECT_NE(res, HCF_SUCCESS);
1810     EXPECT_EQ(ret, nullptr);
1811 
1812     HcfObjDestroy(cipher);
1813 
1814     HcfObjDestroy(keyPair);
1815     HcfObjDestroy(generator);
1816 }
1817 
1818 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest014, TestSize.Level0)
1819 {
1820     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1821     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1822     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1823     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1824     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1825 
1826     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1827     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1828     EXPECT_EQ(res, HCF_SUCCESS);
1829     HcfKeyPair *keyPair = nullptr;
1830     res = generator->generateKeyPair(generator, &keyPair);
1831     EXPECT_EQ(res, HCF_SUCCESS);
1832     EXPECT_NE(keyPair, nullptr);
1833 
1834     HcfCipher *cipher = nullptr;
1835     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1836     EXPECT_EQ(res, HCF_SUCCESS);
1837     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MD_NAME_STR, nullptr);
1838     EXPECT_NE(res, HCF_SUCCESS);
1839     HcfObjDestroy(cipher);
1840 
1841     HcfObjDestroy(keyPair);
1842     HcfObjDestroy(generator);
1843 }
1844 
1845 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest015, TestSize.Level0)
1846 {
1847     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1848     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1849     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1850     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1851     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1852 
1853     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1854     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1855     EXPECT_EQ(res, HCF_SUCCESS);
1856     HcfKeyPair *keyPair = nullptr;
1857     res = generator->generateKeyPair(generator, &keyPair);
1858     EXPECT_EQ(res, HCF_SUCCESS);
1859     EXPECT_NE(keyPair, nullptr);
1860 
1861     HcfCipher *cipher = nullptr;
1862     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1863     EXPECT_EQ(res, HCF_SUCCESS);
1864     res = cipher->getCipherSpecUint8Array(nullptr, OAEP_MD_NAME_STR, nullptr);
1865     EXPECT_NE(res, HCF_SUCCESS);
1866     HcfObjDestroy(cipher);
1867 
1868     HcfObjDestroy(keyPair);
1869     HcfObjDestroy(generator);
1870 }
1871 
1872 HWTEST_F(CryptoRsaCipherTest, CryptoRsaCipherTest016, TestSize.Level0)
1873 {
1874     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1875     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1876     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1877     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1878     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1879 
1880     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1881     HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1882     EXPECT_EQ(res, HCF_SUCCESS);
1883     HcfKeyPair *keyPair = nullptr;
1884     res = generator->generateKeyPair(generator, &keyPair);
1885     EXPECT_EQ(res, HCF_SUCCESS);
1886     EXPECT_NE(keyPair, nullptr);
1887 
1888     HcfCipher *cipher = nullptr;
1889     HcfBlob retBlob = { .data = nullptr, .len = 0 };
1890     res = HcfCipherCreate("RSA|PKCS1_OAEP|SHA256|MGF1_SHA256", &cipher);
1891     EXPECT_EQ(res, HCF_SUCCESS);
1892     res = cipher->getCipherSpecUint8Array(cipher, OAEP_MD_NAME_STR, &retBlob);
1893     EXPECT_NE(res, HCF_SUCCESS);
1894     EXPECT_EQ(retBlob.data, nullptr);
1895 
1896     HcfObjDestroy(cipher);
1897 
1898     HcfObjDestroy(keyPair);
1899     HcfObjDestroy(generator);
1900 }
1901 }
1902