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