1 /*
2  * Copyright (C) 2022-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 #include "asy_key_generator.h"
19 #include "blob.h"
20 #include "detailed_rsa_key_params.h"
21 #include "memory.h"
22 #include "openssl_common.h"
23 #include "signature.h"
24 #include "cstring"
25 
26 
27 using namespace std;
28 using namespace testing::ext;
29 
30 namespace {
31 class CryptoRsaVerifyTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
SetUp()39 void CryptoRsaVerifyTest::SetUp() {}
TearDown()40 void CryptoRsaVerifyTest::TearDown() {}
SetUpTestCase()41 void CryptoRsaVerifyTest::SetUpTestCase() {}
TearDownTestCase()42 void CryptoRsaVerifyTest::TearDownTestCase() {}
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 
89 // check pss salt len in PSS padding
90 const char *g_sha256MdName = "SHA256";
91 const char *g_mgf1Name = "MGF1";
92 constexpr int PSS_INVLAID_SALTLEN = -5;
93 constexpr int PSS_NORMAL_SALTLEN = 32;
94 constexpr int PSS_TRAILER_FIELD_LEN = 1;
95 }
96 
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)97 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
98 {
99     for (size_t i = 0; i < destLen; i++) {
100         dest[i] = str[i];
101     }
102     return;
103 }
104 
EndianSwap(unsigned char * pData,int startIndex,int length)105 static void EndianSwap(unsigned char *pData, int startIndex, int length)
106 {
107     int cnt = length / 2;
108     int start = startIndex;
109     int end  = startIndex + length - 1;
110     unsigned char tmp;
111     for (int i = 0; i < cnt; i++) {
112         tmp = pData[start + i];
113         pData[start + i] = pData[end - i];
114         pData[end - i] = tmp;
115     }
116 }
117 
118 // 2048 defined the length of byte array
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)119 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
120 {
121     RemoveLastChar(CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
122     if (!IsBigEndian()) {
123         // the device is not big endian
124         EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
125     }
126     returnSpec->n.data = dataN;
127     returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
128     returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
129     returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
130     return;
131 }
132 
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)133 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
134     HcfRsaKeyPairParamsSpec *returnPairSpec)
135 {
136     HcfRsaCommParamsSpec rsaCommSpec = {};
137     GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
138     RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
139     RemoveLastChar(CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
140     if (!IsBigEndian()) {
141         // the device is not big endian
142         EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
143         EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
144     }
145     returnPairSpec->pk.data = dataE;
146     returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
147     returnPairSpec->sk.data = dataD;
148     returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
149     returnPairSpec->base = rsaCommSpec;
150     returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
151 }
152 
153 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest100, TestSize.Level0)
154 {
155     HcfVerify *verify = nullptr;
156     int32_t res = HcfVerifyCreate("RSA1024|PSS|SHA256", &verify);
157     EXPECT_NE(res, HCF_SUCCESS);
158     ASSERT_EQ(verify, nullptr);
159 
160     HcfObjDestroy(verify);
161 }
162 
163 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest110, TestSize.Level0)
164 {
165     HcfVerify *verify = nullptr;
166     int32_t res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
167     EXPECT_EQ(res, HCF_SUCCESS);
168     ASSERT_NE(verify, nullptr);
169 
170     HcfObjDestroy(verify);
171 }
172 
173 // incorrect case : init signer with nullptr public key.
174 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest120, TestSize.Level0)
175 {
176     HcfResult res = HCF_SUCCESS;
177     HcfVerify *verify = nullptr;
178     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
179     EXPECT_EQ(res, HCF_SUCCESS);
180     res = verify->init(verify, nullptr, nullptr);
181     EXPECT_NE(res, HCF_SUCCESS);
182 
183     HcfObjDestroy(verify);
184 }
185 
186 // incorrect case : init signer with private Key.
187 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest130, TestSize.Level0)
188 {
189     HcfAsyKeyGenerator *generator = nullptr;
190     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
191     HcfKeyPair *keyPair = nullptr;
192     res = generator->generateKeyPair(generator, nullptr, &keyPair);
193     EXPECT_EQ(res, HCF_SUCCESS);
194 
195     HcfVerify *verify = nullptr;
196     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
197     EXPECT_EQ(res, HCF_SUCCESS);
198     res = verify->init(verify, nullptr, (HcfPubKey *)keyPair->priKey);
199     EXPECT_NE(res, HCF_SUCCESS);
200 
201     HcfObjDestroy(keyPair);
202     HcfObjDestroy(generator);
203     HcfObjDestroy(verify);
204 }
205 
206 // incorrect case : init with other class (not cipher).
207 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest140, TestSize.Level0)
208 {
209     HcfAsyKeyGenerator *generator = nullptr;
210     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
211     HcfKeyPair *keyPair = nullptr;
212     res = generator->generateKeyPair(generator, nullptr, &keyPair);
213     EXPECT_EQ(res, HCF_SUCCESS);
214 
215     HcfVerify *verify = nullptr;
216     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
217     EXPECT_EQ(res, HCF_SUCCESS);
218     res = verify->init((HcfVerify *)generator, nullptr, keyPair->pubKey);
219     EXPECT_NE(res, HCF_SUCCESS);
220 
221     HcfObjDestroy(keyPair);
222     HcfObjDestroy(generator);
223     HcfObjDestroy(verify);
224 }
225 
226 // incorrect case : update with other class (not cipher).
227 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest150, TestSize.Level0)
228 {
229     HcfResult res = HCF_SUCCESS;
230     HcfAsyKeyGenerator *generator = nullptr;
231     res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
232 
233     HcfVerify *verify = nullptr;
234     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
235     EXPECT_EQ(res, HCF_SUCCESS);
236 
237     uint8_t plan[] = "this is rsa verify test.";
238     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
239     res = verify->update((HcfVerify *)generator, &input);
240     EXPECT_NE(res, HCF_SUCCESS);
241 
242     HcfObjDestroy(verify);
243     HcfObjDestroy(generator);
244 }
245 
246 // incorrect case : verify with other class (not cipher).
247 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest160, TestSize.Level0)
248 {
249     HcfResult res = HCF_SUCCESS;
250     HcfAsyKeyGenerator *generator = nullptr;
251     res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
252 
253     HcfVerify *verify = nullptr;
254     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
255     EXPECT_EQ(res, HCF_SUCCESS);
256 
257     uint8_t plan[] = "this is rsa verify test.";
258     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
259     bool result = verify->verify((HcfVerify *)generator, &input, &input);
260     EXPECT_NE(result, true);
261 
262     HcfObjDestroy(verify);
263     HcfObjDestroy(generator);
264 }
265 
266 // incorrect case : use update function before intialize.
267 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest170, TestSize.Level0)
268 {
269     HcfResult res = HCF_SUCCESS;
270     HcfVerify *verify = nullptr;
271     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
272     EXPECT_EQ(res, HCF_SUCCESS);
273 
274     uint8_t plan[] = "this is rsa verify test.";
275     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
276     res = verify->update(verify, &input);
277     EXPECT_NE(res, HCF_SUCCESS);
278 
279     HcfObjDestroy(verify);
280 }
281 
282 // incorrect case : use verify function before intialize.
283 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest180, TestSize.Level0)
284 {
285     HcfResult res = HCF_SUCCESS;
286     HcfVerify *verify = nullptr;
287     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
288     EXPECT_EQ(res, HCF_SUCCESS);
289 
290     uint8_t plan[] = "this is rsa verify test.";
291     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
292     bool result = verify->verify(verify, nullptr, &input);
293     EXPECT_NE(result, true);
294 
295     HcfObjDestroy(verify);
296 }
297 
298 // incorrect case : update with nullptr inputBlob.
299 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest190, TestSize.Level0)
300 {
301     HcfAsyKeyGenerator *generator = nullptr;
302     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
303 
304     HcfKeyPair *keyPair = nullptr;
305     res = generator->generateKeyPair(generator, nullptr, &keyPair);
306     EXPECT_EQ(res, HCF_SUCCESS);
307 
308     HcfPubKey *pubkey = keyPair->pubKey;
309 
310     HcfVerify *verify = nullptr;
311     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
312     EXPECT_EQ(res, HCF_SUCCESS);
313     res = verify->init(verify, nullptr, pubkey);
314     EXPECT_EQ(res, HCF_SUCCESS);
315     res = verify->update(verify, nullptr);
316     EXPECT_NE(res, 1);
317 
318     HcfObjDestroy(verify);
319     HcfObjDestroy(keyPair);
320     HcfObjDestroy(generator);
321 }
322 
323 // incorrect case : verify with nullptr outputBlob.
324 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest191, TestSize.Level0)
325 {
326     HcfAsyKeyGenerator *generator = nullptr;
327     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
328 
329     HcfKeyPair *keyPair = nullptr;
330     res = generator->generateKeyPair(generator, nullptr, &keyPair);
331     EXPECT_EQ(res, HCF_SUCCESS);
332 
333     HcfPubKey *pubkey = keyPair->pubKey;
334 
335     HcfVerify *verify = nullptr;
336     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
337     EXPECT_EQ(res, HCF_SUCCESS);
338     res = verify->init(verify, nullptr, pubkey);
339     EXPECT_EQ(res, HCF_SUCCESS);
340     res = verify->verify(verify, nullptr, nullptr);
341     EXPECT_NE(res, 1);
342 
343     HcfObjDestroy(verify);
344     HcfObjDestroy(keyPair);
345     HcfObjDestroy(generator);
346 }
347 
348 // incorrect case : init verify twice
349 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest192, TestSize.Level0)
350 {
351     HcfAsyKeyGenerator *generator = nullptr;
352     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
353     HcfKeyPair *keyPair = nullptr;
354     res = generator->generateKeyPair(generator, nullptr, &keyPair);
355     EXPECT_EQ(res, HCF_SUCCESS);
356 
357     HcfPubKey *pubkey = keyPair->pubKey;
358     HcfVerify *verify = nullptr;
359     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
360     EXPECT_EQ(res, HCF_SUCCESS);
361 
362     res = verify->init(verify, nullptr, pubkey);
363     EXPECT_EQ(res, HCF_SUCCESS);
364     res = verify->init(verify, nullptr, pubkey);
365     EXPECT_NE(res, HCF_SUCCESS);
366 
367     HcfObjDestroy(verify);
368     HcfObjDestroy(keyPair);
369     HcfObjDestroy(generator);
370 }
371 
372 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest200, TestSize.Level0)
373 {
374     uint8_t plan[] = "this is rsa verify test.";
375     HcfAsyKeyGenerator *generator = nullptr;
376     HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
377     HcfKeyPair *keyPair = nullptr;
378     res = generator->generateKeyPair(generator, nullptr, &keyPair);
379     EXPECT_EQ(res, HCF_SUCCESS);
380 
381     HcfPubKey *pubkey = keyPair->pubKey;
382     HcfPriKey *prikey = keyPair->priKey;
383     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
384     HcfBlob verifyData = {.data = nullptr, .len = 0};
385     HcfSign *sign = nullptr;
386     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
387     EXPECT_EQ(res, HCF_SUCCESS);
388     res = sign->init(sign, nullptr, prikey);
389     EXPECT_EQ(res, HCF_SUCCESS);
390     res = sign->sign(sign, &input, &verifyData);
391     HcfObjDestroy(sign);
392 
393     HcfVerify *verify = nullptr;
394     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
395     EXPECT_EQ(res, HCF_SUCCESS);
396     res = verify->init(verify, nullptr, pubkey);
397     EXPECT_EQ(res, HCF_SUCCESS);
398     bool result = verify->verify(verify, &input, &verifyData);
399     EXPECT_EQ(result, true);
400     HcfObjDestroy(verify);
401 
402     HcfFree(verifyData.data);
403     HcfObjDestroy(keyPair);
404     HcfObjDestroy(generator);
405 }
406 
407 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest210, TestSize.Level0)
408 {
409     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
410         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
411     HcfAsyKeyGenerator *generator = nullptr;
412     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
413 
414     HcfKeyPair *keyPair = nullptr;
415     res = generator->generateKeyPair(generator, nullptr, &keyPair);
416     EXPECT_EQ(res, HCF_SUCCESS);
417 
418     HcfPubKey *pubkey = keyPair->pubKey;
419     HcfPriKey *prikey = keyPair->priKey;
420 
421     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
422     HcfBlob verifyData = {.data = nullptr, .len = 0};
423     HcfSign *sign = nullptr;
424     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
425     EXPECT_EQ(res, HCF_SUCCESS);
426     res = sign->init(sign, nullptr, prikey);
427     EXPECT_EQ(res, HCF_SUCCESS);
428     res = sign->sign(sign, &input, &verifyData);
429     HcfObjDestroy(sign);
430 
431     HcfVerify *verify = nullptr;
432     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
433     EXPECT_EQ(res, HCF_SUCCESS);
434     res = verify->init(verify, nullptr, pubkey);
435     EXPECT_EQ(res, HCF_SUCCESS);
436     res = verify->verify(verify, &input, &verifyData);
437     EXPECT_EQ(res, 1);
438     HcfObjDestroy(verify);
439 
440     HcfFree(verifyData.data);
441     HcfObjDestroy(keyPair);
442     HcfObjDestroy(generator);
443 }
444 
445 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest220, TestSize.Level0)
446 {
447     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
448         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
449     HcfAsyKeyGenerator *generator = nullptr;
450     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
451 
452     HcfKeyPair *keyPair = nullptr;
453     res = generator->generateKeyPair(generator, nullptr, &keyPair);
454     EXPECT_EQ(res, HCF_SUCCESS);
455 
456     HcfPubKey *pubkey = keyPair->pubKey;
457     HcfPriKey *prikey = keyPair->priKey;
458 
459     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
460     HcfBlob verifyData = {.data = nullptr, .len = 0};
461     HcfSign *sign = nullptr;
462     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &sign);
463     EXPECT_EQ(res, HCF_SUCCESS);
464     res = sign->init(sign, nullptr, prikey);
465     EXPECT_EQ(res, HCF_SUCCESS);
466     res = sign->sign(sign, &input, &verifyData);
467     HcfObjDestroy(sign);
468 
469     HcfVerify *verify = nullptr;
470     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
471     EXPECT_EQ(res, HCF_SUCCESS);
472     res = verify->init(verify, nullptr, pubkey);
473     EXPECT_EQ(res, HCF_SUCCESS);
474     res = verify->verify(verify, &input, &verifyData);
475     EXPECT_EQ(res, 1);
476     HcfObjDestroy(verify);
477 
478     HcfFree(verifyData.data);
479     HcfObjDestroy(keyPair);
480     HcfObjDestroy(generator);
481 }
482 
483 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest230, TestSize.Level0)
484 {
485     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
486         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
487     HcfAsyKeyGenerator *generator = nullptr;
488     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
489 
490     HcfKeyPair *keyPair = nullptr;
491     res = generator->generateKeyPair(generator, nullptr, &keyPair);
492     EXPECT_EQ(res, HCF_SUCCESS);
493 
494     HcfPubKey *pubkey = keyPair->pubKey;
495     HcfPriKey *prikey = keyPair->priKey;
496 
497     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
498     HcfBlob verifyData = {.data = nullptr, .len = 0};
499     HcfSign *sign = nullptr;
500     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
501     EXPECT_EQ(res, HCF_SUCCESS);
502     res = sign->init(sign, nullptr, prikey);
503     EXPECT_EQ(res, HCF_SUCCESS);
504     res = sign->sign(sign, &input, &verifyData);
505     HcfObjDestroy(sign);
506 
507     HcfVerify *verify = nullptr;
508     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify);
509     EXPECT_EQ(res, HCF_SUCCESS);
510     res = verify->init(verify, nullptr, pubkey);
511     EXPECT_EQ(res, HCF_SUCCESS);
512     res = verify->verify(verify, &input, &verifyData);
513     EXPECT_EQ(res, 1);
514     HcfObjDestroy(verify);
515 
516     HcfFree(verifyData.data);
517     HcfObjDestroy(keyPair);
518     HcfObjDestroy(generator);
519 }
520 
521 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest240, TestSize.Level0)
522 {
523     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
524         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
525     uint8_t errorverify[] = "asdfasdfasdfasf";
526     HcfAsyKeyGenerator *generator = nullptr;
527     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
528 
529     HcfKeyPair *keyPair = nullptr;
530     res = generator->generateKeyPair(generator, nullptr, &keyPair);
531     EXPECT_EQ(res, HCF_SUCCESS);
532 
533     HcfPubKey *pubkey = keyPair->pubKey;
534     HcfPriKey *prikey = keyPair->priKey;
535 
536     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
537     HcfBlob verifyData = {.data = nullptr, .len = 0};
538     HcfBlob invalidverifyData = {.data = errorverify, .len = strlen((char *)errorverify)};
539     HcfSign *sign = nullptr;
540     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
541     EXPECT_EQ(res, HCF_SUCCESS);
542     res = sign->init(sign, nullptr, prikey);
543     EXPECT_EQ(res, HCF_SUCCESS);
544     res = sign->sign(sign, &input, &verifyData);
545     HcfObjDestroy(sign);
546 
547     HcfVerify *verify = nullptr;
548     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify);
549     EXPECT_EQ(res, HCF_SUCCESS);
550     res = verify->init(verify, nullptr, pubkey);
551     EXPECT_EQ(res, HCF_SUCCESS);
552     res = verify->verify(verify, &input, &invalidverifyData);
553     EXPECT_EQ(res, 0);
554     HcfObjDestroy(verify);
555 
556     HcfFree(verifyData.data);
557     HcfObjDestroy(keyPair);
558     HcfObjDestroy(generator);
559 }
560 
561 // Incorrect case: different mode
562 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest250, TestSize.Level0)
563 {
564     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
565         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
566     HcfAsyKeyGenerator *generator = nullptr;
567     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
568 
569     HcfKeyPair *keyPair = nullptr;
570     res = generator->generateKeyPair(generator, nullptr, &keyPair);
571     EXPECT_EQ(res, HCF_SUCCESS);
572 
573     HcfPubKey *pubkey = keyPair->pubKey;
574     HcfPriKey *prikey = keyPair->priKey;
575 
576     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
577     HcfBlob verifyData = {.data = nullptr, .len = 0};
578     HcfSign *sign = nullptr;
579     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
580     EXPECT_EQ(res, HCF_SUCCESS);
581     res = sign->init(sign, nullptr, prikey);
582     EXPECT_EQ(res, HCF_SUCCESS);
583     res = sign->sign(sign, &input, &verifyData);
584     HcfObjDestroy(sign);
585 
586     HcfVerify *verify = nullptr;
587     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
588     EXPECT_EQ(res, HCF_SUCCESS);
589     res = verify->init(verify, nullptr, pubkey);
590     EXPECT_EQ(res, HCF_SUCCESS);
591     res = verify->verify(verify, &input, &verifyData);
592     EXPECT_EQ(res, 0);
593     HcfObjDestroy(verify);
594 
595     HcfFree(verifyData.data);
596     HcfObjDestroy(keyPair);
597     HcfObjDestroy(generator);
598 }
599 
600 // Incorrect case: different mgf1md
601 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest260, TestSize.Level0)
602 {
603     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
604         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
605     HcfAsyKeyGenerator *generator = nullptr;
606     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
607 
608     HcfKeyPair *keyPair = nullptr;
609     res = generator->generateKeyPair(generator, nullptr, &keyPair);
610     EXPECT_EQ(res, HCF_SUCCESS);
611 
612     HcfPubKey *pubkey = keyPair->pubKey;
613     HcfPriKey *prikey = keyPair->priKey;
614 
615     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
616     HcfBlob verifyData = {.data = nullptr, .len = 0};
617     HcfSign *sign = nullptr;
618     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
619     EXPECT_EQ(res, HCF_SUCCESS);
620     res = sign->init(sign, nullptr, prikey);
621     EXPECT_EQ(res, HCF_SUCCESS);
622     res = sign->sign(sign, &input, &verifyData);
623     HcfObjDestroy(sign);
624 
625     HcfVerify *verify = nullptr;
626     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
627     EXPECT_EQ(res, HCF_SUCCESS);
628     res = verify->init(verify, nullptr, pubkey);
629     EXPECT_EQ(res, HCF_SUCCESS);
630     res = verify->verify(verify, &input, &verifyData);
631     EXPECT_EQ(res, 0);
632     HcfObjDestroy(verify);
633 
634     HcfFree(verifyData.data);
635     HcfObjDestroy(keyPair);
636     HcfObjDestroy(generator);
637 }
638 
639 
640 // Incorrect case: different pkcs1 md, verify fail
641 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest270, TestSize.Level0)
642 {
643     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
644         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
645     HcfAsyKeyGenerator *generator = nullptr;
646     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
647 
648     HcfKeyPair *keyPair = nullptr;
649     res = generator->generateKeyPair(generator, nullptr, &keyPair);
650     EXPECT_EQ(res, HCF_SUCCESS);
651 
652     HcfPubKey *pubkey = keyPair->pubKey;
653     HcfPriKey *prikey = keyPair->priKey;
654 
655     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
656     HcfBlob verifyData = {.data = nullptr, .len = 0};
657     HcfSign *sign = nullptr;
658     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
659     EXPECT_EQ(res, HCF_SUCCESS);
660     res = sign->init(sign, nullptr, prikey);
661     EXPECT_EQ(res, HCF_SUCCESS);
662     res = sign->sign(sign, &input, &verifyData);
663     HcfObjDestroy(sign);
664 
665     HcfVerify *verify = nullptr;
666     res = HcfVerifyCreate("RSA1024|PKCS1|SHA512", &verify);
667     EXPECT_EQ(res, HCF_SUCCESS);
668     res = verify->init(verify, nullptr, pubkey);
669     EXPECT_EQ(res, HCF_SUCCESS);
670     res = verify->verify(verify, &input, &verifyData);
671     EXPECT_EQ(res, 0);
672     HcfObjDestroy(verify);
673 
674     HcfFree(verifyData.data);
675     HcfObjDestroy(keyPair);
676     HcfObjDestroy(generator);
677 }
678 
679 // check update_func in PSS padding
680 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest280, TestSize.Level0)
681 {
682     uint8_t plan1[] = "this is rsa verify test plane1 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
683         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
684     uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
685         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
686     HcfAsyKeyGenerator *generator = nullptr;
687     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
688 
689     HcfKeyPair *keyPair = nullptr;
690     res = generator->generateKeyPair(generator, nullptr, &keyPair);
691     EXPECT_EQ(res, HCF_SUCCESS);
692 
693     HcfPubKey *pubkey = keyPair->pubKey;
694     HcfPriKey *prikey = keyPair->priKey;
695 
696     HcfBlob input = {.data = plan1, .len = strlen((char *)plan1)};
697     HcfBlob inputEx = {.data = plan2, .len = strlen((char *)plan2)};
698     HcfBlob verifyData = {.data = nullptr, .len = 0};
699     HcfSign *sign = nullptr;
700     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
701     EXPECT_EQ(res, HCF_SUCCESS);
702     res = sign->init(sign, nullptr, prikey);
703     EXPECT_EQ(res, HCF_SUCCESS);
704     res = sign->update(sign, &input);
705     EXPECT_EQ(res, HCF_SUCCESS);
706     res = sign->sign(sign, &inputEx, &verifyData);
707     EXPECT_EQ(res, HCF_SUCCESS);
708     HcfObjDestroy(sign);
709 
710     HcfVerify *verify = nullptr;
711     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
712     EXPECT_EQ(res, HCF_SUCCESS);
713     res = verify->init(verify, nullptr, pubkey);
714     EXPECT_EQ(res, HCF_SUCCESS);
715     res = verify->update(verify, &input);
716     EXPECT_EQ(res, HCF_SUCCESS);
717     res = verify->verify(verify, &inputEx, &verifyData);
718     EXPECT_EQ(res, 1);
719     HcfObjDestroy(verify);
720 
721     HcfFree(verifyData.data);
722     HcfObjDestroy(keyPair);
723     HcfObjDestroy(generator);
724 }
725 
726 // check update in PKCS1 padding
727 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest290, TestSize.Level0)
728 {
729     uint8_t plan1[] = "this is rsa verify test plane1 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
730         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
731     uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
732         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
733     uint8_t plan3[] = "this is rsa verify test plane3 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
734         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
735 
736     HcfAsyKeyGenerator *generator = nullptr;
737     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
738 
739     HcfKeyPair *keyPair = nullptr;
740     res = generator->generateKeyPair(generator, nullptr, &keyPair);
741     EXPECT_EQ(res, HCF_SUCCESS);
742 
743     HcfPubKey *pubkey = keyPair->pubKey;
744     HcfPriKey *prikey = keyPair->priKey;
745 
746     HcfBlob input1 = {.data = plan1, .len = strlen((char *)plan1)};
747     HcfBlob input2 = {.data = plan2, .len = strlen((char *)plan2)};
748     HcfBlob input3 = {.data = plan3, .len = strlen((char *)plan3)};
749     HcfBlob verifyData = {.data = nullptr, .len = 0};
750     HcfSign *sign = nullptr;
751     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
752     EXPECT_EQ(res, HCF_SUCCESS);
753     res = sign->init(sign, nullptr, prikey);
754     EXPECT_EQ(res, HCF_SUCCESS);
755     res = sign->update(sign, &input1);
756     EXPECT_EQ(res, HCF_SUCCESS);
757     res = sign->update(sign, &input2);
758     EXPECT_EQ(res, HCF_SUCCESS);
759     res = sign->sign(sign, &input3, &verifyData);
760     EXPECT_EQ(res, HCF_SUCCESS);
761     HcfObjDestroy(sign);
762 
763     HcfVerify *verify = nullptr;
764     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify);
765     EXPECT_EQ(res, HCF_SUCCESS);
766     res = verify->init(verify, nullptr, pubkey);
767     EXPECT_EQ(res, HCF_SUCCESS);
768     res = verify->update(verify, &input1);
769     EXPECT_EQ(res, HCF_SUCCESS);
770     res = verify->update(verify, &input2);
771     EXPECT_EQ(res, HCF_SUCCESS);
772     res = verify->verify(verify, &input3, &verifyData);
773     EXPECT_EQ(res, 1);
774     HcfObjDestroy(verify);
775 
776     HcfFree(verifyData.data);
777     HcfObjDestroy(keyPair);
778     HcfObjDestroy(generator);
779 }
780 
781 // incorrect case : pss set before init -> fail -> success(new)
782 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest300, TestSize.Level0)
783 {
784     HcfAsyKeyGenerator *generator = nullptr;
785     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
786 
787     HcfKeyPair *keyPair = nullptr;
788     res = generator->generateKeyPair(generator, nullptr, &keyPair);
789     EXPECT_EQ(res, HCF_SUCCESS);
790 
791     HcfPubKey *pubkey = keyPair->pubKey;
792     HcfVerify *verify = nullptr;
793     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
794     EXPECT_EQ(res, HCF_SUCCESS);
795 
796     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
797     EXPECT_EQ(res, HCF_SUCCESS);
798     res = verify->init(verify, nullptr, pubkey);
799     EXPECT_EQ(res, HCF_SUCCESS);
800     res = verify->update(verify, nullptr);
801     EXPECT_NE(res, 1);
802 
803     HcfObjDestroy(verify);
804     HcfObjDestroy(keyPair);
805     HcfObjDestroy(generator);
806 }
807 
808 // incorrect case : pss set abnormal len
809 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest301, TestSize.Level0)
810 {
811     HcfAsyKeyGenerator *generator = nullptr;
812     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
813 
814     HcfKeyPair *keyPair = nullptr;
815     res = generator->generateKeyPair(generator, nullptr, &keyPair);
816     EXPECT_EQ(res, HCF_SUCCESS);
817 
818     HcfPubKey *pubkey = keyPair->pubKey;
819     HcfVerify *verify = nullptr;
820     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
821     EXPECT_EQ(res, HCF_SUCCESS);
822 
823     res = verify->init(verify, nullptr, pubkey);
824     EXPECT_EQ(res, HCF_SUCCESS);
825     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_INVLAID_SALTLEN);
826     EXPECT_NE(res, HCF_SUCCESS);
827     res = verify->update(verify, nullptr);
828     EXPECT_NE(res, 1);
829 
830     HcfObjDestroy(verify);
831     HcfObjDestroy(keyPair);
832     HcfObjDestroy(generator);
833 }
834 
835 // correct case : pss set abnormal len after init
836 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest302, TestSize.Level0)
837 {
838     HcfAsyKeyGenerator *generator = nullptr;
839     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
840 
841     HcfKeyPair *keyPair = nullptr;
842     res = generator->generateKeyPair(generator, nullptr, &keyPair);
843     EXPECT_EQ(res, HCF_SUCCESS);
844 
845     HcfPubKey *pubkey = keyPair->pubKey;
846     HcfVerify *verify = nullptr;
847     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &verify);
848     EXPECT_EQ(res, HCF_SUCCESS);
849 
850     res = verify->init(verify, nullptr, pubkey);
851     EXPECT_EQ(res, HCF_SUCCESS);
852     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
853     EXPECT_EQ(res, HCF_SUCCESS);
854     res = verify->update(verify, nullptr);
855     EXPECT_NE(res, 1);
856 
857     HcfObjDestroy(verify);
858     HcfObjDestroy(keyPair);
859     HcfObjDestroy(generator);
860 }
861 
862 // correct case : pss get func after init except saltLen.
863 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest303, TestSize.Level0)
864 {
865     HcfAsyKeyGenerator *generator = nullptr;
866     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
867 
868     HcfKeyPair *keyPair = nullptr;
869     res = generator->generateKeyPair(generator, nullptr, &keyPair);
870     EXPECT_EQ(res, HCF_SUCCESS);
871 
872     HcfPubKey *pubkey = keyPair->pubKey;
873     HcfVerify *verify = nullptr;
874     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
875     EXPECT_EQ(res, HCF_SUCCESS);
876 
877     res = verify->init(verify, nullptr, pubkey);
878     EXPECT_EQ(res, HCF_SUCCESS);
879     int32_t retInt = 0;
880     res = verify->getVerifySpecInt(verify, PSS_TRAILER_FIELD_INT, &retInt);
881     EXPECT_EQ(res, HCF_SUCCESS);
882     EXPECT_EQ(retInt, PSS_TRAILER_FIELD_LEN);
883     res = verify->update(verify, nullptr);
884     EXPECT_NE(res, 1);
885 
886     HcfObjDestroy(verify);
887     HcfObjDestroy(keyPair);
888     HcfObjDestroy(generator);
889 }
890 
891 // get string
892 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest304, TestSize.Level0)
893 {
894     HcfAsyKeyGenerator *generator = nullptr;
895     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
896 
897     HcfKeyPair *keyPair = nullptr;
898     res = generator->generateKeyPair(generator, nullptr, &keyPair);
899     EXPECT_EQ(res, HCF_SUCCESS);
900 
901     HcfPubKey *pubkey = keyPair->pubKey;
902     HcfVerify *verify = nullptr;
903     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
904     EXPECT_EQ(res, HCF_SUCCESS);
905 
906     res = verify->init(verify, nullptr, pubkey);
907     EXPECT_EQ(res, HCF_SUCCESS);
908     char *retStr = nullptr;
909     res = verify->getVerifySpecString(verify, PSS_MD_NAME_STR, &retStr);
910     EXPECT_EQ(res, HCF_SUCCESS);
911     EXPECT_STREQ(g_sha256MdName, retStr);
912     res = verify->update(verify, nullptr);
913     EXPECT_NE(res, 1);
914 
915     HcfFree(retStr);
916     HcfObjDestroy(verify);
917     HcfObjDestroy(keyPair);
918     HcfObjDestroy(generator);
919 }
920 
921 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest305, TestSize.Level0)
922 {
923     HcfAsyKeyGenerator *generator = nullptr;
924     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
925 
926     HcfKeyPair *keyPair = nullptr;
927     res = generator->generateKeyPair(generator, nullptr, &keyPair);
928     EXPECT_EQ(res, HCF_SUCCESS);
929 
930     HcfPubKey *pubkey = keyPair->pubKey;
931     HcfVerify *verify = nullptr;
932     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
933     EXPECT_EQ(res, HCF_SUCCESS);
934 
935     res = verify->init(verify, nullptr, pubkey);
936     EXPECT_EQ(res, HCF_SUCCESS);
937     char *retStr = nullptr;
938     res = verify->getVerifySpecString(verify, PSS_MGF_NAME_STR, &retStr);
939     EXPECT_EQ(res, HCF_SUCCESS);
940     EXPECT_STREQ(g_mgf1Name, retStr);
941     res = verify->update(verify, nullptr);
942     EXPECT_NE(res, 1);
943 
944     HcfFree(retStr);
945     HcfObjDestroy(verify);
946     HcfObjDestroy(keyPair);
947     HcfObjDestroy(generator);
948 }
949 
950 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest306, TestSize.Level0)
951 {
952     HcfAsyKeyGenerator *generator = nullptr;
953     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
954 
955     HcfKeyPair *keyPair = nullptr;
956     res = generator->generateKeyPair(generator, nullptr, &keyPair);
957     EXPECT_EQ(res, HCF_SUCCESS);
958 
959     HcfPubKey *pubkey = keyPair->pubKey;
960     HcfVerify *verify = nullptr;
961     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
962     EXPECT_EQ(res, HCF_SUCCESS);
963 
964     res = verify->init(verify, nullptr, pubkey);
965     EXPECT_EQ(res, HCF_SUCCESS);
966     char *retStr = nullptr;
967     res = verify->getVerifySpecString(verify, PSS_MGF1_MD_STR, &retStr);
968     EXPECT_EQ(res, HCF_SUCCESS);
969     EXPECT_STREQ(g_sha256MdName, retStr);
970     res = verify->update(verify, nullptr);
971     EXPECT_NE(res, 1);
972 
973     HcfFree(retStr);
974     HcfObjDestroy(verify);
975     HcfObjDestroy(keyPair);
976     HcfObjDestroy(generator);
977 }
978 
979 // incorrect case : pkcs1 set pss saltLen
980 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest307, TestSize.Level3)
981 {
982     HcfAsyKeyGenerator *generator = nullptr;
983     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
984 
985     HcfKeyPair *keyPair = nullptr;
986     res = generator->generateKeyPair(generator, nullptr, &keyPair);
987     EXPECT_EQ(res, HCF_SUCCESS);
988 
989     HcfPubKey *pubkey = keyPair->pubKey;
990     HcfVerify *verify = nullptr;
991     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify);
992     EXPECT_EQ(res, HCF_SUCCESS);
993 
994     res = verify->init(verify, nullptr, pubkey);
995     EXPECT_EQ(res, HCF_SUCCESS);
996     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
997     EXPECT_NE(res, HCF_SUCCESS);
998     res = verify->update(verify, nullptr);
999     EXPECT_NE(res, 1);
1000 
1001     HcfObjDestroy(verify);
1002     HcfObjDestroy(keyPair);
1003     HcfObjDestroy(generator);
1004 }
1005 
1006 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest308, TestSize.Level0)
1007 {
1008     uint8_t plan[] = "this is rsa verify test aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1009         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1010     HcfAsyKeyGenerator *generator = nullptr;
1011     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
1012 
1013     HcfKeyPair *keyPair = nullptr;
1014     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1015     EXPECT_EQ(res, HCF_SUCCESS);
1016 
1017     HcfPubKey *pubkey = keyPair->pubKey;
1018     HcfPriKey *prikey = keyPair->priKey;
1019 
1020     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
1021     HcfBlob verifyData = {.data = nullptr, .len = 0};
1022     HcfSign *sign = nullptr;
1023     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
1024     EXPECT_EQ(res, HCF_SUCCESS);
1025     res = sign->init(sign, nullptr, prikey);
1026     EXPECT_EQ(res, HCF_SUCCESS);
1027     res = sign->sign(sign, &input, &verifyData);
1028     HcfObjDestroy(sign);
1029 
1030     HcfVerify *verify = nullptr;
1031     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256", &verify);
1032     EXPECT_EQ(res, HCF_SUCCESS);
1033     res = verify->init(verify, nullptr, pubkey);
1034     EXPECT_EQ(res, HCF_SUCCESS);
1035     res = verify->verify(verify, &input, &verifyData);
1036     EXPECT_EQ(res, 1);
1037     HcfObjDestroy(verify);
1038 
1039     HcfFree(verifyData.data);
1040     HcfObjDestroy(keyPair);
1041     HcfObjDestroy(generator);
1042 }
1043 // old key and test update setSignSpecInt func
1044 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest001, TestSize.Level0)
1045 {
1046     uint8_t plan1[] = "this is rsa verify test plane1 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1047         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1048     uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1049         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1050     HcfAsyKeyGenerator *generator = nullptr;
1051     int32_t res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
1052 
1053     HcfKeyPair *keyPair = nullptr;
1054     res = generator->generateKeyPair(generator, nullptr, &keyPair);
1055     EXPECT_EQ(res, HCF_SUCCESS);
1056 
1057     HcfPubKey *pubkey = keyPair->pubKey;
1058     HcfPriKey *prikey = keyPair->priKey;
1059 
1060     HcfBlob input = {.data = plan1, .len = strlen((char *)plan1)};
1061     HcfBlob inputEx = {.data = plan2, .len = strlen((char *)plan2)};
1062     HcfBlob verifyData = {.data = nullptr, .len = 0};
1063     HcfSign *sign = nullptr;
1064     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
1065     EXPECT_EQ(res, HCF_SUCCESS);
1066     res = sign->init(sign, nullptr, prikey);
1067     EXPECT_EQ(res, HCF_SUCCESS);
1068 
1069     // set sign pss saltlen
1070     res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1071     EXPECT_EQ(res, HCF_SUCCESS);
1072     res = sign->update(sign, &input);
1073     EXPECT_EQ(res, HCF_SUCCESS);
1074     res = sign->sign(sign, &inputEx, &verifyData);
1075     EXPECT_EQ(res, HCF_SUCCESS);
1076     HcfObjDestroy(sign);
1077 
1078     HcfVerify *verify = nullptr;
1079     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
1080     EXPECT_EQ(res, HCF_SUCCESS);
1081     res = verify->init(verify, nullptr, pubkey);
1082     EXPECT_EQ(res, HCF_SUCCESS);
1083 
1084     // set verify attribute
1085     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1086     EXPECT_EQ(res, HCF_SUCCESS);
1087 
1088     res = verify->update(verify, &input);
1089     EXPECT_EQ(res, HCF_SUCCESS);
1090     res = verify->verify(verify, &inputEx, &verifyData);
1091     // true == 1
1092     EXPECT_EQ(res, 1);
1093     HcfObjDestroy(verify);
1094 
1095     HcfFree(verifyData.data);
1096     HcfObjDestroy(keyPair);
1097     HcfObjDestroy(generator);
1098 }
1099 
1100 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest002, TestSize.Level0)
1101 {
1102     uint8_t plan1[] = "this is rsa verify test plane1 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1103         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1104     uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1105         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1106     int32_t res = HCF_SUCCESS;
1107     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1108     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1109     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1110     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1111     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1112 
1113     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1114     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1115     EXPECT_EQ(res, HCF_SUCCESS);
1116     EXPECT_NE(generator, nullptr);
1117 
1118     HcfKeyPair *keyPair = nullptr;
1119     res = generator->generateKeyPair(generator, &keyPair);
1120     EXPECT_EQ(res, HCF_SUCCESS);
1121     EXPECT_NE(keyPair, nullptr);
1122 
1123     HcfBlob input = {.data = plan1, .len = strlen((char *)plan1)};
1124     HcfBlob inputEx = {.data = plan2, .len = strlen((char *)plan2)};
1125     HcfBlob verifyData = {.data = nullptr, .len = 0};
1126     HcfSign *sign = nullptr;
1127     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
1128     EXPECT_EQ(res, HCF_SUCCESS);
1129     // set sign pss saltlen
1130     res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1131     EXPECT_EQ(res, HCF_SUCCESS);
1132     res = sign->init(sign, nullptr, keyPair->priKey);
1133     EXPECT_EQ(res, HCF_SUCCESS);
1134     res = sign->update(sign, &input);
1135     EXPECT_EQ(res, HCF_SUCCESS);
1136     res = sign->sign(sign, &inputEx, &verifyData);
1137     EXPECT_EQ(res, HCF_SUCCESS);
1138     HcfObjDestroy(sign);
1139 
1140     HcfVerify *verify = nullptr;
1141     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
1142     EXPECT_EQ(res, HCF_SUCCESS);
1143     res = verify->init(verify, nullptr, keyPair->pubKey);
1144     EXPECT_EQ(res, HCF_SUCCESS);
1145     // set verify attribute
1146     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1147     EXPECT_EQ(res, HCF_SUCCESS);
1148     res = verify->update(verify, &input);
1149     EXPECT_EQ(res, HCF_SUCCESS);
1150     res = verify->verify(verify, &inputEx, &verifyData);
1151     // true == 1
1152     EXPECT_EQ(res, 1);
1153     HcfObjDestroy(verify);
1154 
1155     HcfFree(verifyData.data);
1156     HcfObjDestroy(keyPair);
1157     HcfObjDestroy(generator);
1158 }
1159 
1160 // test verify pss signature, sign after init and verify before init.
1161 HWTEST_F(CryptoRsaVerifyTest, CryptoRsaVerifyTest003, TestSize.Level0)
1162 {
1163     uint8_t plan1[] = "this is rsa verify test plane1 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1164         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1165     uint8_t plan2[] = "this is rsa verify test plane2 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
1166         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.";
1167     int32_t res = HCF_SUCCESS;
1168     HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1169     unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1170     unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1171     unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1172     GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1173 
1174     HcfAsyKeyGeneratorBySpec *generator = nullptr;
1175     res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1176     EXPECT_EQ(res, HCF_SUCCESS);
1177     EXPECT_NE(generator, nullptr);
1178 
1179     HcfKeyPair *keyPair = nullptr;
1180     res = generator->generateKeyPair(generator, &keyPair);
1181     EXPECT_EQ(res, HCF_SUCCESS);
1182     EXPECT_NE(keyPair, nullptr);
1183 
1184     HcfBlob input = {.data = plan1, .len = strlen((char *)plan1)};
1185     HcfBlob inputEx = {.data = plan2, .len = strlen((char *)plan2)};
1186     HcfBlob verifyData = {.data = nullptr, .len = 0};
1187     HcfSign *sign = nullptr;
1188     res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
1189     EXPECT_EQ(res, HCF_SUCCESS);
1190 
1191     res = sign->init(sign, nullptr, keyPair->priKey);
1192     EXPECT_EQ(res, HCF_SUCCESS);
1193     res = sign->setSignSpecInt(sign, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1194     EXPECT_EQ(res, HCF_SUCCESS);
1195     res = sign->update(sign, &input);
1196     EXPECT_EQ(res, HCF_SUCCESS);
1197     res = sign->sign(sign, &inputEx, &verifyData);
1198     EXPECT_EQ(res, HCF_SUCCESS);
1199     HcfObjDestroy(sign);
1200 
1201     HcfVerify *verify = nullptr;
1202     res = HcfVerifyCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &verify);
1203     EXPECT_EQ(res, HCF_SUCCESS);
1204     // set verify attribute
1205     res = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, PSS_NORMAL_SALTLEN);
1206     EXPECT_EQ(res, HCF_SUCCESS);
1207     res = verify->init(verify, nullptr, keyPair->pubKey);
1208     EXPECT_EQ(res, HCF_SUCCESS);
1209     res = verify->update(verify, &input);
1210     EXPECT_EQ(res, HCF_SUCCESS);
1211     res = verify->verify(verify, &inputEx, &verifyData);
1212     // true == 1
1213     EXPECT_EQ(res, 1);
1214     HcfObjDestroy(verify);
1215 
1216     HcfFree(verifyData.data);
1217     HcfObjDestroy(keyPair);
1218     HcfObjDestroy(generator);
1219 }
1220 }
1221