1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "cstring"
18 #include "securec.h"
19 #include "asy_key_generator.h"
20 #include "blob.h"
21 #include "detailed_rsa_key_params.h"
22 #include "memory.h"
23 #include "openssl_common.h"
24 #include "md.h"
25 #include "signature.h"
26 
27 using namespace std;
28 using namespace testing::ext;
29 
30 namespace {
31 class CryptoRsaOnlySignAndVerifyRecoverTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
SetUp()39 void CryptoRsaOnlySignAndVerifyRecoverTest::SetUp() {}
TearDown()40 void CryptoRsaOnlySignAndVerifyRecoverTest::TearDown() {}
SetUpTestCase()41 void CryptoRsaOnlySignAndVerifyRecoverTest::SetUpTestCase() {}
TearDownTestCase()42 void CryptoRsaOnlySignAndVerifyRecoverTest::TearDownTestCase() {}
43 
RsaOnlySignCreateTest(const char * algoName)44 static void RsaOnlySignCreateTest(const char *algoName)
45 {
46     HcfResult res = HCF_SUCCESS;
47     HcfSign *sign = nullptr;
48     res = HcfSignCreate(algoName, &sign);
49     EXPECT_EQ(res, HCF_SUCCESS);
50     EXPECT_NE(sign, nullptr);
51     EXPECT_NE(sign->base.getClass(), nullptr);
52     EXPECT_NE(sign->base.destroy, nullptr);
53     EXPECT_NE(sign->init, nullptr);
54     EXPECT_NE(sign->update, nullptr);
55     EXPECT_NE(sign->sign, nullptr);
56     HcfObjDestroy(sign);
57 }
58 
RsaOnlySignCreateIncorrectTest(const char * algoName,HcfResult ret)59 static void RsaOnlySignCreateIncorrectTest(const char *algoName, HcfResult ret)
60 {
61     HcfResult res = HCF_SUCCESS;
62     HcfSign *sign = nullptr;
63     res = HcfSignCreate(algoName, &sign);
64     EXPECT_EQ(res, ret);
65     EXPECT_EQ(sign, nullptr);
66 }
67 
RsaOnlySignTest(const char * keyAlgoName,const char * algoName,const char * plan)68 static void RsaOnlySignTest(const char *keyAlgoName, const char *algoName, const char *plan)
69 {
70     HcfResult res = HCF_SUCCESS;
71     HcfAsyKeyGenerator *generator = nullptr;
72     res = HcfAsyKeyGeneratorCreate(keyAlgoName, &generator);
73     HcfKeyPair *keyPair = nullptr;
74     res = generator->generateKeyPair(generator, nullptr, &keyPair);
75     EXPECT_EQ(res, HCF_SUCCESS);
76 
77     HcfPriKey *prikey = keyPair->priKey;
78     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen(plan)};
79     HcfBlob verifyData = {.data = nullptr, .len = 0};
80     HcfSign *sign = nullptr;
81     res = HcfSignCreate(algoName, &sign);
82     EXPECT_EQ(res, HCF_SUCCESS);
83     res = sign->init(sign, nullptr, prikey);
84     EXPECT_EQ(res, HCF_SUCCESS);
85     res = sign->sign(sign, &input, &verifyData);
86     EXPECT_EQ(res, HCF_SUCCESS);
87 
88     HcfObjDestroy(sign);
89     HcfFree(verifyData.data);
90     HcfObjDestroy(keyPair);
91     HcfObjDestroy(generator);
92 }
93 
RsaOnlySignIncorrectTest(const char * keyAlgoName,const char * algoName,const char * plan)94 static void RsaOnlySignIncorrectTest(const char *keyAlgoName, const char *algoName, const char *plan)
95 {
96     HcfResult res = HCF_SUCCESS;
97     HcfAsyKeyGenerator *generator = nullptr;
98     res = HcfAsyKeyGeneratorCreate(keyAlgoName, &generator);
99     HcfKeyPair *keyPair = nullptr;
100     res = generator->generateKeyPair(generator, nullptr, &keyPair);
101     EXPECT_EQ(res, HCF_SUCCESS);
102 
103     HcfPriKey *prikey = keyPair->priKey;
104     HcfBlob input = {.data = (uint8_t *)plan, .len = strlen(plan)};
105     HcfBlob verifyData = {.data = nullptr, .len = 0};
106     HcfSign *sign = nullptr;
107     res = HcfSignCreate(algoName, &sign);
108     EXPECT_EQ(res, HCF_SUCCESS);
109     res = sign->init(sign, nullptr, prikey);
110     EXPECT_EQ(res, HCF_SUCCESS);
111     res = sign->sign(sign, &input, &verifyData);
112     EXPECT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
113 
114     HcfObjDestroy(sign);
115     HcfObjDestroy(keyPair);
116     HcfObjDestroy(generator);
117 }
118 
119 // HcfSignCreate OnlySign correct_case
120 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest100, TestSize.Level0)
121 {
122     RsaOnlySignCreateTest("RSA512|PKCS1|NoHash|OnlySign");
123     RsaOnlySignCreateTest("RSA512|PKCS1|MD5|OnlySign");
124     RsaOnlySignCreateTest("RSA512|PKCS1|SHA1|OnlySign");
125     RsaOnlySignCreateTest("RSA512|PKCS1|SHA224|OnlySign");
126     RsaOnlySignCreateTest("RSA512|PKCS1|SHA256|OnlySign");
127     RsaOnlySignCreateTest("RSA512|PKCS1|SHA384|OnlySign");
128 }
129 
130 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest110, TestSize.Level0)
131 {
132     RsaOnlySignCreateTest("RSA768|PKCS1|NoHash|OnlySign");
133     RsaOnlySignCreateTest("RSA768|PKCS1|MD5|OnlySign");
134     RsaOnlySignCreateTest("RSA768|PKCS1|SHA1|OnlySign");
135     RsaOnlySignCreateTest("RSA768|PKCS1|SHA224|OnlySign");
136     RsaOnlySignCreateTest("RSA768|PKCS1|SHA256|OnlySign");
137     RsaOnlySignCreateTest("RSA768|PKCS1|SHA384|OnlySign");
138     RsaOnlySignCreateTest("RSA768|PKCS1|SHA512|OnlySign");
139 }
140 
141 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest120, TestSize.Level0)
142 {
143     RsaOnlySignCreateTest("RSA1024|PKCS1|NoHash|OnlySign");
144     RsaOnlySignCreateTest("RSA1024|PKCS1|MD5|OnlySign");
145     RsaOnlySignCreateTest("RSA1024|PKCS1|SHA1|OnlySign");
146     RsaOnlySignCreateTest("RSA1024|PKCS1|SHA224|OnlySign");
147     RsaOnlySignCreateTest("RSA1024|PKCS1|SHA256|OnlySign");
148     RsaOnlySignCreateTest("RSA1024|PKCS1|SHA384|OnlySign");
149     RsaOnlySignCreateTest("RSA1024|PKCS1|SHA512|OnlySign");
150 }
151 
152 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest130, TestSize.Level0)
153 {
154     RsaOnlySignCreateTest("RSA2048|PKCS1|NoHash|OnlySign");
155     RsaOnlySignCreateTest("RSA2048|PKCS1|MD5|OnlySign");
156     RsaOnlySignCreateTest("RSA2048|PKCS1|SHA1|OnlySign");
157     RsaOnlySignCreateTest("RSA2048|PKCS1|SHA224|OnlySign");
158     RsaOnlySignCreateTest("RSA2048|PKCS1|SHA256|OnlySign");
159     RsaOnlySignCreateTest("RSA2048|PKCS1|SHA384|OnlySign");
160     RsaOnlySignCreateTest("RSA2048|PKCS1|SHA512|OnlySign");
161 }
162 
163 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest140, TestSize.Level0)
164 {
165     RsaOnlySignCreateTest("RSA3072|PKCS1|NoHash|OnlySign");
166     RsaOnlySignCreateTest("RSA3072|PKCS1|MD5|OnlySign");
167     RsaOnlySignCreateTest("RSA3072|PKCS1|SHA1|OnlySign");
168     RsaOnlySignCreateTest("RSA3072|PKCS1|SHA224|OnlySign");
169     RsaOnlySignCreateTest("RSA3072|PKCS1|SHA256|OnlySign");
170     RsaOnlySignCreateTest("RSA3072|PKCS1|SHA384|OnlySign");
171     RsaOnlySignCreateTest("RSA3072|PKCS1|SHA512|OnlySign");
172 }
173 
174 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest150, TestSize.Level0)
175 {
176     RsaOnlySignCreateTest("RSA4096|PKCS1|NoHash|OnlySign");
177     RsaOnlySignCreateTest("RSA4096|PKCS1|MD5|OnlySign");
178     RsaOnlySignCreateTest("RSA4096|PKCS1|SHA1|OnlySign");
179     RsaOnlySignCreateTest("RSA4096|PKCS1|SHA224|OnlySign");
180     RsaOnlySignCreateTest("RSA4096|PKCS1|SHA256|OnlySign");
181     RsaOnlySignCreateTest("RSA4096|PKCS1|SHA384|OnlySign");
182     RsaOnlySignCreateTest("RSA4096|PKCS1|SHA512|OnlySign");
183 }
184 
185 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest160, TestSize.Level0)
186 {
187     RsaOnlySignCreateTest("RSA8192|PKCS1|NoHash|OnlySign");
188     RsaOnlySignCreateTest("RSA8192|PKCS1|MD5|OnlySign");
189     RsaOnlySignCreateTest("RSA8192|PKCS1|SHA1|OnlySign");
190     RsaOnlySignCreateTest("RSA8192|PKCS1|SHA224|OnlySign");
191     RsaOnlySignCreateTest("RSA8192|PKCS1|SHA256|OnlySign");
192     RsaOnlySignCreateTest("RSA8192|PKCS1|SHA384|OnlySign");
193     RsaOnlySignCreateTest("RSA8192|PKCS1|SHA512|OnlySign");
194 }
195 
196 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest170, TestSize.Level0)
197 {
198     RsaOnlySignCreateTest("RSA512|NoPadding|NoHash|OnlySign");
199     RsaOnlySignCreateTest("RSA768|NoPadding|NoHash|OnlySign");
200     RsaOnlySignCreateTest("RSA1024|NoPadding|NoHash|OnlySign");
201     RsaOnlySignCreateTest("RSA2048|NoPadding|NoHash|OnlySign");
202     RsaOnlySignCreateTest("RSA3072|NoPadding|NoHash|OnlySign");
203     RsaOnlySignCreateTest("RSA4096|NoPadding|NoHash|OnlySign");
204     RsaOnlySignCreateTest("RSA8192|NoPadding|NoHash|OnlySign");
205 }
206 
207 // HcfSignCreate OnlySign Incorrect case
208 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest180, TestSize.Level0)
209 {
210     RsaOnlySignCreateIncorrectTest("RSA1024aa|PKCS1|SHA256|OnlySign", HCF_INVALID_PARAMS);
211     RsaOnlySignCreateIncorrectTest("RSA1024|PKCS1aa|SHA256|OnlySign", HCF_INVALID_PARAMS);
212     RsaOnlySignCreateIncorrectTest("RSA1024|PKCS1|SHA256aa|OnlySign", HCF_INVALID_PARAMS);
213     RsaOnlySignCreateIncorrectTest("RSA1024|PKCS1|SHA256|OnlySignaa", HCF_INVALID_PARAMS);
214     RsaOnlySignCreateIncorrectTest("RSA1024|PKCS1|SHA256|123123123123123123212312312321"
215         "123123123123213asdasdasdasdasdasdasdasdasdasdasdasdasdsasdasds12|OnlySign", HCF_INVALID_PARAMS);
216     RsaOnlySignCreateIncorrectTest("RSA1024|PSS|SHA256|MGF1_SHA256|OnlySign", HCF_INVALID_PARAMS);
217     RsaOnlySignCreateIncorrectTest("DSA1024|PKCS1|SHA256|OnlySign", HCF_NOT_SUPPORT);
218 }
219 
220 // incorrect case : OnlySign init signer with nullptr private key.
221 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest270, TestSize.Level0)
222 {
223     HcfResult res = HCF_SUCCESS;
224     HcfSign *sign = nullptr;
225     res = HcfSignCreate("RSA1024|PKCS1|NoHash|OnlySign", &sign);
226     EXPECT_EQ(res, HCF_SUCCESS);
227 
228     res = sign->init(sign, nullptr, nullptr);
229     EXPECT_EQ(res, HCF_INVALID_PARAMS);
230 
231     HcfObjDestroy(sign);
232 }
233 
234 // incorrect case : OnlySign init signer with public Key.
235 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest280, TestSize.Level0)
236 {
237     HcfResult res = HCF_SUCCESS;
238     HcfAsyKeyGenerator *generator = nullptr;
239     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
240     HcfKeyPair *keyPair = nullptr;
241     res = generator->generateKeyPair(generator, nullptr, &keyPair);
242     EXPECT_EQ(res, HCF_SUCCESS);
243 
244     HcfSign *sign = nullptr;
245     res = HcfSignCreate("RSA1024|PKCS1|NoHash|OnlySign", &sign);
246     EXPECT_EQ(res, HCF_SUCCESS);
247 
248     HcfPubKey *pubKey = keyPair->pubKey;
249 
250     res = sign->init(sign, nullptr, (HcfPriKey *)pubKey);
251     EXPECT_EQ(res, HCF_INVALID_PARAMS);
252 
253     HcfObjDestroy(sign);
254     HcfObjDestroy(generator);
255     HcfObjDestroy(keyPair);
256 }
257 
258 // incorrect case : OnlySign use update function.
259 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest290, TestSize.Level0)
260 {
261     HcfResult res = HCF_SUCCESS;
262     HcfSign *sign = nullptr;
263     res = HcfSignCreate("RSA1024|PKCS1|NoHash|OnlySign", &sign);
264     EXPECT_EQ(res, HCF_SUCCESS);
265     uint8_t plan[] = "this is rsa verify test.";
266     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
267     HcfAsyKeyGenerator *generator = nullptr;
268     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
269     HcfKeyPair *keyPair = nullptr;
270     res = generator->generateKeyPair(generator, nullptr, &keyPair);
271     EXPECT_EQ(res, HCF_SUCCESS);
272 
273     HcfPriKey *prikey = keyPair->priKey;
274     res = sign->init(sign, nullptr, prikey);
275     EXPECT_EQ(res, HCF_SUCCESS);
276     res = sign->update(sign, &input);
277     EXPECT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
278 
279     HcfObjDestroy(sign);
280     HcfObjDestroy(keyPair);
281     HcfObjDestroy(generator);
282 }
283 
284 // incorrect case : use OnlySign sign function before intialize.
285 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest291, TestSize.Level0)
286 {
287     HcfResult res = HCF_SUCCESS;
288 
289     HcfSign *sign = nullptr;
290     res = HcfSignCreate("RSA1024|PKCS1|NoHash|OnlySign", &sign);
291     EXPECT_EQ(res, HCF_SUCCESS);
292 
293     uint8_t plan[] = "this is rsa verify test.";
294     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
295     HcfBlob signatureData = {.data = nullptr, .len = 0};
296     res = sign->sign(sign, &input, &signatureData);
297     EXPECT_EQ(res, HCF_INVALID_PARAMS);
298 
299     HcfObjDestroy(sign);
300 }
301 
302 // incorrect case : OnlySign sign with nullptr outputBlob.
303 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest292, TestSize.Level0)
304 {
305     HcfResult res = HCF_SUCCESS;
306     HcfSign *sign = nullptr;
307     res = HcfSignCreate("RSA1024|PKCS1|NoHash|OnlySign", &sign);
308     EXPECT_EQ(res, HCF_SUCCESS);
309     HcfAsyKeyGenerator *generator = nullptr;
310     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
311     HcfKeyPair *keyPair = nullptr;
312     res = generator->generateKeyPair(generator, nullptr, &keyPair);
313     EXPECT_EQ(res, HCF_SUCCESS);
314 
315     HcfPriKey *prikey = keyPair->priKey;
316     res = sign->init(sign, nullptr, prikey);
317     EXPECT_EQ(res, HCF_SUCCESS);
318     res = sign->sign(sign, nullptr, nullptr);
319     EXPECT_EQ(res, HCF_INVALID_PARAMS);
320 
321     HcfObjDestroy(sign);
322     HcfObjDestroy(keyPair);
323     HcfObjDestroy(generator);
324 }
325 
326 // correct case: OnlySign init and sign
327 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest300, TestSize.Level0)
328 {
329     RsaOnlySignTest("RSA512|PRIMES_2", "RSA512|PKCS1|NoHash|OnlySign", "01234567890123456789");
330     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|NoHash|OnlySign", "01234567890123456789");
331     RsaOnlySignTest("RSA2048|PRIMES_2", "RSA2048|PKCS1|NoHash|OnlySign", "01234567890123456789");
332     RsaOnlySignTest("RSA4096|PRIMES_2", "RSA4096|PKCS1|NoHash|OnlySign", "01234567890123456789");
333 }
334 
335 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest310, TestSize.Level0)
336 {
337     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|NoPadding|NoHash|OnlySign",
338         "0123456789012345678901234567890123456789012345678901234567890123456789"
339         "0123456789012345678901234567890123456789012345678901234567");
340 }
341 
342 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest320, TestSize.Level0)
343 {
344     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|MD5|OnlySign", "0123456789012345");
345     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA1|OnlySign", "01234567890123456789");
346     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA224|OnlySign",
347         "0123456789012345678901234567");
348     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA256|OnlySign",
349         "01234567890123456789012345678901");
350     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA384|OnlySign",
351         "012345678901234567890123456789012345678901234567");
352     RsaOnlySignTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA512|OnlySign",
353         "0123456789012345678901234567890123456789012345678901234567890123");
354 }
355 
356 // incorrect case: OnlySign init and sign
357 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest330, TestSize.Level0)
358 {
359     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|MD5|OnlySign", "012345678901234");
360     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|MD5|OnlySign", "01234567890123456");
361 
362     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA1|OnlySign", "0123456789012345678");
363     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA1|OnlySign", "012345678901234567890");
364 
365     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA224|OnlySign",
366         "012345678901234567890123456");
367     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA224|OnlySign",
368         "01234567890123456789012345678");
369 
370     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA256|OnlySign",
371         "0123456789012345678901234567890");
372     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA256|OnlySign",
373         "012345678901234567890123456789012");
374 
375     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA384|OnlySign",
376         "01234567890123456789012345678901234567890123456");
377     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA384|OnlySign",
378         "0123456789012345678901234567890123456789012345678");
379 
380     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA512|OnlySign",
381         "012345678901234567890123456789012345678901234567890123456789012");
382     RsaOnlySignIncorrectTest("RSA1024|PRIMES_2", "RSA1024|PKCS1|SHA512|OnlySign",
383         "01234567890123456789012345678901234567890123456789012345678901234");
384 }
385 
386 // incorrect case: OnlySign double init sign
387 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaOnlySignTest500, TestSize.Level0)
388 {
389     HcfAsyKeyGenerator *generator = nullptr;
390     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
391     HcfKeyPair *keyPair = nullptr;
392     res = generator->generateKeyPair(generator, nullptr, &keyPair);
393     EXPECT_EQ(res, HCF_SUCCESS);
394 
395     HcfPriKey *prikey = keyPair->priKey;
396     HcfSign *sign = nullptr;
397     res = HcfSignCreate("RSA1024|PKCS1|SHA512|OnlySign", &sign);
398     EXPECT_EQ(res, HCF_SUCCESS);
399 
400     res = sign->init(sign, nullptr, prikey);
401     EXPECT_EQ(res, HCF_SUCCESS);
402     res = sign->init(sign, nullptr, prikey);
403     EXPECT_EQ(res, HCF_INVALID_PARAMS);
404 
405     HcfObjDestroy(sign);
406     HcfObjDestroy(keyPair);
407     HcfObjDestroy(generator);
408 }
409 
CryptoRsaVerifyRecoverCreateTest(const char * algoName)410 static void CryptoRsaVerifyRecoverCreateTest(const char *algoName)
411 {
412     HcfResult res = HCF_SUCCESS;
413     HcfVerify *verify = nullptr;
414     res = HcfVerifyCreate(algoName, &verify);
415     EXPECT_EQ(res, HCF_SUCCESS);
416     EXPECT_NE(verify, nullptr);
417     EXPECT_NE(verify->base.getClass(), nullptr);
418     EXPECT_NE(verify->base.destroy, nullptr);
419     EXPECT_NE(verify->init, nullptr);
420     EXPECT_NE(verify->update, nullptr);
421     EXPECT_NE(verify->verify, nullptr);
422     EXPECT_NE(verify->recover, nullptr);
423     HcfObjDestroy(verify);
424 }
425 
RsaVerifyRecoverIncorrectTest(const char * algoName,HcfResult ret)426 static void RsaVerifyRecoverIncorrectTest(const char *algoName, HcfResult ret)
427 {
428     HcfResult res = HCF_SUCCESS;
429     HcfVerify *verify = nullptr;
430     res = HcfVerifyCreate(algoName, &verify);
431     EXPECT_EQ(res, ret);
432     EXPECT_EQ(verify, nullptr);
433 }
434 
435 // HcfVerifyCreate Recover correct_case
436 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest100, TestSize.Level0)
437 {
438     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|NoHash|Recover");
439     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|MD5|Recover");
440     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|SHA1|Recover");
441     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|SHA224|Recover");
442     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|SHA256|Recover");
443     CryptoRsaVerifyRecoverCreateTest("RSA512|PKCS1|SHA384|Recover");
444 }
445 
446 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest110, TestSize.Level0)
447 {
448     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|NoHash|Recover");
449     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|MD5|Recover");
450     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|SHA1|Recover");
451     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|SHA224|Recover");
452     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|SHA256|Recover");
453     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|SHA384|Recover");
454     CryptoRsaVerifyRecoverCreateTest("RSA768|PKCS1|SHA512|Recover");
455 }
456 
457 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest120, TestSize.Level0)
458 {
459     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|NoHash|Recover");
460     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|MD5|Recover");
461     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|SHA1|Recover");
462     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|SHA224|Recover");
463     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|SHA256|Recover");
464     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|SHA384|Recover");
465     CryptoRsaVerifyRecoverCreateTest("RSA1024|PKCS1|SHA512|Recover");
466 }
467 
468 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest130, TestSize.Level0)
469 {
470     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|NoHash|Recover");
471     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|MD5|Recover");
472     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|SHA1|Recover");
473     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|SHA224|Recover");
474     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|SHA256|Recover");
475     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|SHA384|Recover");
476     CryptoRsaVerifyRecoverCreateTest("RSA2048|PKCS1|SHA512|Recover");
477 }
478 
479 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest140, TestSize.Level0)
480 {
481     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|NoHash|Recover");
482     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|MD5|Recover");
483     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|SHA1|Recover");
484     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|SHA224|Recover");
485     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|SHA256|Recover");
486     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|SHA384|Recover");
487     CryptoRsaVerifyRecoverCreateTest("RSA3072|PKCS1|SHA512|Recover");
488 }
489 
490 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest150, TestSize.Level0)
491 {
492     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|NoHash|Recover");
493     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|MD5|Recover");
494     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|SHA1|Recover");
495     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|SHA224|Recover");
496     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|SHA256|Recover");
497     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|SHA384|Recover");
498     CryptoRsaVerifyRecoverCreateTest("RSA4096|PKCS1|SHA512|Recover");
499 }
500 
501 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest160, TestSize.Level0)
502 {
503     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|NoHash|Recover");
504     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|MD5|Recover");
505     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|SHA1|Recover");
506     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|SHA224|Recover");
507     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|SHA256|Recover");
508     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|SHA384|Recover");
509     CryptoRsaVerifyRecoverCreateTest("RSA8192|PKCS1|SHA512|Recover");
510 }
511 
512 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest170, TestSize.Level0)
513 {
514     CryptoRsaVerifyRecoverCreateTest("RSA512|NoPadding|NoHash|Recover");
515     CryptoRsaVerifyRecoverCreateTest("RSA768|NoPadding|NoHash|Recover");
516     CryptoRsaVerifyRecoverCreateTest("RSA1024|NoPadding|NoHash|Recover");
517     CryptoRsaVerifyRecoverCreateTest("RSA2048|NoPadding|NoHash|Recover");
518     CryptoRsaVerifyRecoverCreateTest("RSA3072|NoPadding|NoHash|Recover");
519     CryptoRsaVerifyRecoverCreateTest("RSA4096|NoPadding|NoHash|Recover");
520     CryptoRsaVerifyRecoverCreateTest("RSA8192|NoPadding|NoHash|Recover");
521 }
522 
523 // HcfVerifyCreate OnlySign Incorrect case
524 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest180, TestSize.Level0)
525 {
526     RsaVerifyRecoverIncorrectTest("RSA1024aa|PKCS1|SHA256|Recover", HCF_INVALID_PARAMS);
527     RsaVerifyRecoverIncorrectTest("RSA1024|PKCS1aa|SHA256|Recover", HCF_INVALID_PARAMS);
528     RsaVerifyRecoverIncorrectTest("RSA1024|PKCS1|SHA256aa|Recover", HCF_INVALID_PARAMS);
529     RsaVerifyRecoverIncorrectTest("RSA1024|PKCS1|SHA256|Recoveraa", HCF_INVALID_PARAMS);
530     RsaVerifyRecoverIncorrectTest("RSA1024|PKCS1|SHA256|123123123123123123212312312321"
531         "123123123123213asdasdasdasdasdasdasdasdasdasdasdasdasdsasdasds12|Recover", HCF_INVALID_PARAMS);
532     RsaVerifyRecoverIncorrectTest("RSA1024|PSS|SHA256|MGF1_SHA256|Recover", HCF_INVALID_PARAMS);
533     RsaVerifyRecoverIncorrectTest("DSA1024|PKCS1|SHA256|Recover", HCF_NOT_SUPPORT);
534 }
535 
536 // incorrect case : Recover init signer with nullptr public key.
537 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest270, TestSize.Level0)
538 {
539     HcfResult res = HCF_SUCCESS;
540     HcfVerify *verify = nullptr;
541     res = HcfVerifyCreate("RSA1024|PKCS1|NoHash|Recover", &verify);
542     EXPECT_EQ(res, HCF_SUCCESS);
543 
544     res = verify->init(verify, nullptr, nullptr);
545     EXPECT_EQ(res, HCF_INVALID_PARAMS);
546 
547     HcfObjDestroy(verify);
548 }
549 
550 // incorrect case : Recover init verifyer with private Key.
551 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest280, TestSize.Level0)
552 {
553     HcfResult res = HCF_SUCCESS;
554     HcfAsyKeyGenerator *generator = nullptr;
555     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
556     HcfKeyPair *keyPair = nullptr;
557     res = generator->generateKeyPair(generator, nullptr, &keyPair);
558     EXPECT_EQ(res, HCF_SUCCESS);
559 
560     HcfVerify *verify = nullptr;
561     res = HcfVerifyCreate("RSA1024|PKCS1|NoHash|Recover", &verify);
562     EXPECT_EQ(res, HCF_SUCCESS);
563 
564     HcfPriKey *priKey = keyPair->priKey;
565 
566     res = verify->init(verify, nullptr, (HcfPubKey *)priKey);
567     EXPECT_EQ(res, HCF_INVALID_PARAMS);
568 
569     HcfObjDestroy(verify);
570     HcfObjDestroy(generator);
571     HcfObjDestroy(keyPair);
572 }
573 
574 // incorrect case : use Recover recover function before intialize.
575 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest291, TestSize.Level0)
576 {
577     uint8_t plan[] = "01234567890123456789012345678901";
578     HcfAsyKeyGenerator *generator = nullptr;
579     int32_t res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
580 
581     HcfKeyPair *keyPair = nullptr;
582     res = generator->generateKeyPair(generator, nullptr, &keyPair);
583     EXPECT_EQ(res, HCF_SUCCESS);
584 
585     HcfPriKey *prikey = keyPair->priKey;
586 
587     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
588     HcfBlob verifyData = {.data = nullptr, .len = 0};
589     HcfBlob rawSignatureData = {.data = nullptr, .len = 0};
590     HcfSign *sign = nullptr;
591     res = HcfSignCreate("RSA1024|PKCS1|SHA256|OnlySign", &sign);
592     EXPECT_EQ(res, HCF_SUCCESS);
593     res = sign->init(sign, nullptr, prikey);
594     EXPECT_EQ(res, HCF_SUCCESS);
595     res = sign->sign(sign, &input, &verifyData);
596     EXPECT_EQ(res, HCF_SUCCESS);
597     HcfObjDestroy(sign);
598 
599     HcfVerify *verify = nullptr;
600     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
601     EXPECT_EQ(res, HCF_SUCCESS);
602     res = verify->recover(verify, &verifyData, &rawSignatureData);
603     EXPECT_EQ(res, HCF_ERR_CRYPTO_OPERATION);
604 
605     HcfObjDestroy(verify);
606     HcfFree(verifyData.data);
607     HcfObjDestroy(keyPair);
608     HcfObjDestroy(generator);
609 }
610 
611 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverErrTest01, TestSize.Level0)
612 {
613     uint8_t plan[] = "01234567890123456789012345678901";
614     HcfAsyKeyGenerator *generator = nullptr;
615     int32_t res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
616 
617     HcfKeyPair *keyPair = nullptr;
618     res = generator->generateKeyPair(generator, nullptr, &keyPair);
619     EXPECT_EQ(res, HCF_SUCCESS);
620 
621     HcfPriKey *prikey = keyPair->priKey;
622 
623     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
624     HcfBlob verifyData = {.data = nullptr, .len = 0};
625     HcfBlob rawSignatureData = {.data = nullptr, .len = 0};
626     HcfSign *sign = nullptr;
627     res = HcfSignCreate("RSA1024|PKCS1|SHA256|OnlySign", &sign);
628     EXPECT_EQ(res, HCF_SUCCESS);
629     res = sign->init(sign, nullptr, prikey);
630     EXPECT_EQ(res, HCF_SUCCESS);
631     res = sign->sign(sign, &input, &verifyData);
632     EXPECT_EQ(res, HCF_SUCCESS);
633     HcfObjDestroy(sign);
634 
635     HcfVerify *verify = nullptr;
636     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
637     EXPECT_EQ(res, HCF_SUCCESS);
638     res = verify->recover(nullptr, &verifyData, &rawSignatureData);
639     EXPECT_EQ(res, HCF_INVALID_PARAMS);
640 
641     HcfObjDestroy(verify);
642     HcfFree(verifyData.data);
643     HcfObjDestroy(keyPair);
644     HcfObjDestroy(generator);
645 }
646 
647 // incorrect case : Recover recover with nullptr outputBlob.
648 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest292, TestSize.Level0)
649 {
650     HcfResult res = HCF_SUCCESS;
651     HcfAsyKeyGenerator *generator = nullptr;
652     res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
653     HcfKeyPair *keyPair = nullptr;
654     res = generator->generateKeyPair(generator, nullptr, &keyPair);
655     EXPECT_EQ(res, HCF_SUCCESS);
656 
657     HcfPubKey *pubkey = keyPair->pubKey;
658 
659     HcfBlob rawSignatureData = {.data = nullptr, .len = 0};
660     HcfVerify *verify = nullptr;
661     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
662     EXPECT_EQ(res, HCF_SUCCESS);
663     res = verify->init(verify, nullptr, pubkey);
664     EXPECT_EQ(res, HCF_SUCCESS);
665     res = verify->recover(verify, nullptr, &rawSignatureData);
666     EXPECT_EQ(res, HCF_INVALID_PARAMS);
667 
668     HcfObjDestroy(verify);
669     HcfObjDestroy(keyPair);
670     HcfObjDestroy(generator);
671 }
672 
673 // incorrect case: recover double init verify
674 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest293, TestSize.Level0)
675 {
676     HcfAsyKeyGenerator *generator = nullptr;
677     HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
678     HcfKeyPair *keyPair = nullptr;
679     res = generator->generateKeyPair(generator, nullptr, &keyPair);
680     EXPECT_EQ(res, HCF_SUCCESS);
681 
682     HcfPubKey *pubkey = keyPair->pubKey;
683     HcfVerify *verify = nullptr;
684     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
685     EXPECT_EQ(res, HCF_SUCCESS);
686 
687     res = verify->init(verify, nullptr, pubkey);
688     EXPECT_EQ(res, HCF_SUCCESS);
689     res = verify->init(verify, nullptr, pubkey);
690     EXPECT_EQ(res, HCF_INVALID_PARAMS);
691 
692     HcfObjDestroy(verify);
693     HcfObjDestroy(keyPair);
694     HcfObjDestroy(generator);
695 }
696 
697 // correct case : sign and recover
698 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest300, TestSize.Level0)
699 {
700     uint8_t plan[] = "01234567890123456789012345678901";
701     HcfAsyKeyGenerator *generator = nullptr;
702     int32_t res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
703 
704     HcfKeyPair *keyPair = nullptr;
705     res = generator->generateKeyPair(generator, nullptr, &keyPair);
706     EXPECT_EQ(res, HCF_SUCCESS);
707 
708     HcfPubKey *pubkey = keyPair->pubKey;
709     HcfPriKey *prikey = keyPair->priKey;
710 
711     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
712     HcfBlob verifyData = {.data = nullptr, .len = 0};
713     HcfBlob rawSignatureData = {.data = nullptr, .len = 0};
714     HcfSign *sign = nullptr;
715     res = HcfSignCreate("RSA1024|PKCS1|SHA256|OnlySign", &sign);
716     EXPECT_EQ(res, HCF_SUCCESS);
717     res = sign->init(sign, nullptr, prikey);
718     EXPECT_EQ(res, HCF_SUCCESS);
719     res = sign->sign(sign, &input, &verifyData);
720     EXPECT_EQ(res, HCF_SUCCESS);
721     HcfObjDestroy(sign);
722 
723     HcfVerify *verify = nullptr;
724     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
725     EXPECT_EQ(res, HCF_SUCCESS);
726     res = verify->init(verify, nullptr, pubkey);
727     EXPECT_EQ(res, HCF_SUCCESS);
728     res = verify->recover(verify, &verifyData, &rawSignatureData);
729     EXPECT_EQ(res, HCF_SUCCESS);
730     HcfObjDestroy(verify);
731     int resCmp = memcmp(input.data, rawSignatureData.data, rawSignatureData.len);
732     EXPECT_EQ(resCmp, HCF_SUCCESS);
733 
734     HcfFree(verifyData.data);
735     HcfFree(rawSignatureData.data);
736     HcfObjDestroy(keyPair);
737     HcfObjDestroy(generator);
738 }
739 
740 HWTEST_F(CryptoRsaOnlySignAndVerifyRecoverTest, CryptoRsaVerifyRecoverTest310, TestSize.Level0)
741 {
742     uint8_t plan[] = "01234567890123456789012345678901";
743     HcfAsyKeyGenerator *generator = nullptr;
744     int32_t res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
745 
746     HcfKeyPair *keyPair = nullptr;
747     res = generator->generateKeyPair(generator, nullptr, &keyPair);
748     EXPECT_EQ(res, HCF_SUCCESS);
749 
750     HcfPubKey *pubkey = keyPair->pubKey;
751     HcfPriKey *prikey = keyPair->priKey;
752 
753     HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
754     HcfBlob verifyData = {.data = nullptr, .len = 0};
755     HcfBlob rawSignatureData = {.data = nullptr, .len = 0};
756     HcfSign *sign = nullptr;
757     res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
758     EXPECT_EQ(res, HCF_SUCCESS);
759     res = sign->init(sign, nullptr, prikey);
760     EXPECT_EQ(res, HCF_SUCCESS);
761     res = sign->sign(sign, &input, &verifyData);
762     EXPECT_EQ(res, HCF_SUCCESS);
763     HcfObjDestroy(sign);
764 
765     HcfVerify *verify = nullptr;
766     res = HcfVerifyCreate("RSA1024|PKCS1|SHA256|Recover", &verify);
767     EXPECT_EQ(res, HCF_SUCCESS);
768     res = verify->init(verify, nullptr, pubkey);
769     EXPECT_EQ(res, HCF_SUCCESS);
770     res = verify->recover(verify, &verifyData, &rawSignatureData);
771     EXPECT_EQ(res, HCF_SUCCESS);
772     HcfObjDestroy(verify);
773 
774     uint32_t SHA256_LEN = 32;
775     HcfMd *mdObj = nullptr;
776     HcfResult ret = HcfMdCreate("SHA256", &mdObj);
777     ASSERT_EQ(ret, HCF_SUCCESS);
778     struct HcfBlob outBlob = { .data = nullptr, .len = 0 };
779     ret = mdObj->update(mdObj, &input);
780     EXPECT_EQ(ret, HCF_SUCCESS);
781     ret = mdObj->doFinal(mdObj, &outBlob);
782     EXPECT_EQ(ret, HCF_SUCCESS);
783     uint32_t len = mdObj->getMdLength(mdObj);
784     EXPECT_EQ(len, SHA256_LEN);
785 
786     int resCmp = memcmp(outBlob.data, rawSignatureData.data, rawSignatureData.len);
787     EXPECT_EQ(resCmp, HCF_SUCCESS);
788 
789     HcfObjDestroy(mdObj);
790     HcfFree(verifyData.data);
791     HcfFree(rawSignatureData.data);
792     HcfBlobDataClearAndFree(&outBlob);
793     HcfObjDestroy(keyPair);
794     HcfObjDestroy(generator);
795 }
796 }
797