1 /*
2 * Copyright (C) 2022 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 "signature.h"
22 #include "memory.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace {
28 class CryptoRsaSignTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp();
33 void TearDown();
34 };
35
SetUp()36 void CryptoRsaSignTest::SetUp() {}
TearDown()37 void CryptoRsaSignTest::TearDown() {}
SetUpTestCase()38 void CryptoRsaSignTest::SetUpTestCase() {}
TearDownTestCase()39 void CryptoRsaSignTest::TearDownTestCase() {}
40
41 // HcfSignCreate correct_case
42 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest100, TestSize.Level0)
43 {
44 HcfResult res = HCF_SUCCESS;
45 HcfSign *sign = NULL;
46 res = HcfSignCreate("RSA1024|PKCS1|MD5", &sign);
47 EXPECT_EQ(res, HCF_SUCCESS);
48 EXPECT_NE(sign, nullptr);
49 EXPECT_NE(sign->base.getClass(), nullptr);
50 EXPECT_NE(sign->base.destroy, nullptr);
51 EXPECT_NE(sign->init, nullptr);
52 EXPECT_NE(sign->update, nullptr);
53 EXPECT_NE(sign->sign, nullptr);
54 HcfObjDestroy(sign);
55 }
56
57 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest110, TestSize.Level0)
58 {
59 HcfResult res = HCF_SUCCESS;
60 HcfSign *sign = NULL;
61 res = HcfSignCreate("RSA1024|PKCS1|SHA1", &sign);
62 EXPECT_EQ(res, HCF_SUCCESS);
63 EXPECT_NE(sign, nullptr);
64 EXPECT_NE(sign->base.getClass(), nullptr);
65 EXPECT_NE(sign->base.destroy, nullptr);
66 EXPECT_NE(sign->init, nullptr);
67 EXPECT_NE(sign->update, nullptr);
68 EXPECT_NE(sign->sign, nullptr);
69 HcfObjDestroy(sign);
70 }
71
72 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest120, TestSize.Level0)
73 {
74 HcfResult res = HCF_SUCCESS;
75 HcfSign *sign = NULL;
76 res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
77 EXPECT_EQ(res, HCF_SUCCESS);
78 EXPECT_NE(sign, nullptr);
79 EXPECT_NE(sign->base.getClass(), nullptr);
80 EXPECT_NE(sign->base.destroy, nullptr);
81 EXPECT_NE(sign->init, nullptr);
82 EXPECT_NE(sign->update, nullptr);
83 EXPECT_NE(sign->sign, nullptr);
84 HcfObjDestroy(sign);
85 }
86
87 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest130, TestSize.Level0)
88 {
89 HcfResult res = HCF_SUCCESS;
90 HcfSign *sign = NULL;
91 res = HcfSignCreate("RSA1024|PKCS1|SHA512", &sign);
92 EXPECT_EQ(res, HCF_SUCCESS);
93 EXPECT_NE(sign, nullptr);
94 EXPECT_NE(sign->base.getClass(), nullptr);
95 EXPECT_NE(sign->base.destroy, nullptr);
96 EXPECT_NE(sign->init, nullptr);
97 EXPECT_NE(sign->update, nullptr);
98 EXPECT_NE(sign->sign, nullptr);
99 HcfObjDestroy(sign);
100 }
101
102 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest140, TestSize.Level0)
103 {
104 HcfResult res = HCF_SUCCESS;
105 HcfSign *sign = NULL;
106 res = HcfSignCreate("RSA1024|PSS|SHA1|MGF1_SHA1", &sign);
107 EXPECT_EQ(res, HCF_SUCCESS);
108 EXPECT_NE(sign, nullptr);
109 EXPECT_NE(sign->base.getClass(), nullptr);
110 EXPECT_NE(sign->base.destroy, nullptr);
111 EXPECT_NE(sign->init, nullptr);
112 EXPECT_NE(sign->update, nullptr);
113 EXPECT_NE(sign->sign, nullptr);
114 HcfObjDestroy(sign);
115 }
116
117 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest150, TestSize.Level0)
118 {
119 HcfResult res = HCF_SUCCESS;
120 HcfSign *sign = NULL;
121 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA512", &sign);
122 EXPECT_EQ(res, HCF_SUCCESS);
123 EXPECT_NE(sign, nullptr);
124 EXPECT_NE(sign->base.getClass(), nullptr);
125 EXPECT_NE(sign->base.destroy, nullptr);
126 EXPECT_NE(sign->init, nullptr);
127 EXPECT_NE(sign->update, nullptr);
128 EXPECT_NE(sign->sign, nullptr);
129 HcfObjDestroy(sign);
130 }
131
132 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest160, TestSize.Level0)
133 {
134 HcfResult res = HCF_SUCCESS;
135 HcfSign *sign = NULL;
136 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
137 EXPECT_EQ(res, HCF_SUCCESS);
138 EXPECT_NE(sign, nullptr);
139 EXPECT_NE(sign->base.getClass(), nullptr);
140 EXPECT_NE(sign->base.destroy, nullptr);
141 EXPECT_NE(sign->init, nullptr);
142 EXPECT_NE(sign->update, nullptr);
143 EXPECT_NE(sign->sign, nullptr);
144 HcfObjDestroy(sign);
145 }
146
147 // HcfSignCreate Incorrect case
148 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest200, TestSize.Level0)
149 {
150 HcfResult res = HCF_SUCCESS;
151 HcfSign *sign = NULL;
152 res = HcfSignCreate("RSA1024|PSSaa|SHA256|MGF1_SHA256", &sign);
153 EXPECT_NE(res, HCF_SUCCESS);
154 EXPECT_EQ(sign, nullptr);
155 }
156
157 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest210, TestSize.Level0)
158 {
159 HcfResult res = HCF_SUCCESS;
160 HcfSign *sign = NULL;
161 res = HcfSignCreate(NULL, &sign);
162 EXPECT_NE(res, HCF_SUCCESS);
163 EXPECT_EQ(sign, nullptr);
164 }
165
166 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest220, TestSize.Level0)
167 {
168 HcfResult res = HCF_SUCCESS;
169 HcfSign *sign = NULL;
170 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256|123123123123123123212312312321"
171 "123123123123213asdasdasdasdasdasdasdasdasdasdasdasdasdsasdasds12", &sign);
172 EXPECT_NE(res, HCF_SUCCESS);
173 EXPECT_EQ(sign, nullptr);
174 }
175
176 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest230, TestSize.Level0)
177 {
178 HcfResult res = HCF_SUCCESS;
179 HcfSign *sign = NULL;
180 res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", &sign);
181 EXPECT_NE(res, HCF_SUCCESS);
182 EXPECT_EQ(sign, nullptr);
183 }
184
185 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest240, TestSize.Level0)
186 {
187 HcfResult res = HCF_SUCCESS;
188 HcfSign *sign = NULL;
189 res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256asdasdas", &sign);
190 EXPECT_NE(res, HCF_SUCCESS);
191 EXPECT_EQ(sign, nullptr);
192 }
193
194 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest250, TestSize.Level0)
195 {
196 HcfResult res = HCF_SUCCESS;
197 HcfSign *sign = NULL;
198 res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", &sign);
199 EXPECT_NE(res, HCF_SUCCESS);
200 EXPECT_EQ(sign, nullptr);
201 }
202
203 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest260, TestSize.Level0)
204 {
205 HcfResult res = HCF_SUCCESS;
206 res = HcfSignCreate("RSA1024|PSS|SHA256aa|MGF1_SHA256", NULL);
207 EXPECT_NE(res, HCF_SUCCESS);
208 }
209
210 // incorrect case : init signer with NULL private key.
211 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest270, TestSize.Level0)
212 {
213 HcfResult res = HCF_SUCCESS;
214 HcfSign *sign = NULL;
215 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
216 EXPECT_EQ(res, HCF_SUCCESS);
217
218 res = sign->init(sign, NULL, NULL);
219 EXPECT_NE(res, HCF_SUCCESS);
220
221 HcfObjDestroy(sign);
222 }
223
224 // incorrect case : init signer with public Key.
225 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest280, TestSize.Level0)
226 {
227 HcfResult res = HCF_SUCCESS;
228 HcfAsyKeyGenerator *generator = NULL;
229 res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator);
230 HcfKeyPair *keyPair = NULL;
231 res = generator->generateKeyPair(generator, NULL, &keyPair);
232 EXPECT_EQ(res, HCF_SUCCESS);
233
234 HcfSign *sign = NULL;
235 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
236 EXPECT_EQ(res, HCF_SUCCESS);
237
238 HcfPubKey *pubKey = keyPair->pubKey;
239
240 res = sign->init(sign, NULL, (HcfPriKey *)pubKey);
241 EXPECT_NE(res, HCF_SUCCESS);
242
243 HcfObjDestroy(sign);
244 HcfObjDestroy(generator);
245 HcfObjDestroy(keyPair);
246 }
247
248 // incorrect case : use update function before intialize.
249 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest281, TestSize.Level0)
250 {
251 HcfResult res = HCF_SUCCESS;
252 HcfSign *sign = NULL;
253 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
254 EXPECT_EQ(res, HCF_SUCCESS);
255
256 uint8_t plan[] = "this is rsa verify test.";
257 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
258 res = sign->update(sign, &input);
259 EXPECT_NE(res, HCF_SUCCESS);
260
261 HcfObjDestroy(sign);
262 }
263
264 // incorrect case : use sign function before intialize.
265 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest290, TestSize.Level0)
266 {
267 HcfResult res = HCF_SUCCESS;
268
269 HcfSign *sign = NULL;
270 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
271 EXPECT_EQ(res, HCF_SUCCESS);
272
273 uint8_t plan[] = "this is rsa verify test.";
274 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
275 HcfBlob signatureData = {.data = NULL, .len = 0};
276 res = sign->sign(sign, &input, &signatureData);
277 EXPECT_NE(res, HCF_SUCCESS);
278
279 HcfObjDestroy(sign);
280 }
281
282 // incorrect case : init with other class (not cipher).
283 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest291, TestSize.Level0)
284 {
285 HcfResult res = HCF_SUCCESS;
286 HcfAsyKeyGenerator *generator = NULL;
287 res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
288 HcfKeyPair *keyPair = NULL;
289 res = generator->generateKeyPair(generator, NULL, &keyPair);
290 EXPECT_EQ(res, HCF_SUCCESS);
291
292 HcfSign *sign = NULL;
293 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
294 EXPECT_EQ(res, HCF_SUCCESS);
295
296 res = sign->init((HcfSign *)generator, NULL, keyPair->priKey);
297 EXPECT_NE(res, HCF_SUCCESS);
298
299 HcfObjDestroy(sign);
300 HcfObjDestroy(generator);
301 HcfObjDestroy(keyPair);
302 }
303
304 // incorrect case : update with other class (not cipher).
305 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest292, TestSize.Level0)
306 {
307 HcfResult res = HCF_SUCCESS;
308 HcfAsyKeyGenerator *generator = NULL;
309 res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
310 HcfKeyPair *keyPair = NULL;
311 res = generator->generateKeyPair(generator, NULL, &keyPair);
312 EXPECT_EQ(res, HCF_SUCCESS);
313
314 HcfSign *sign = NULL;
315 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
316 EXPECT_EQ(res, HCF_SUCCESS);
317
318 uint8_t plan[] = "this is rsa verify test.";
319 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
320 res = sign->update((HcfSign *)generator, &input);
321 EXPECT_NE(res, HCF_SUCCESS);
322
323 HcfObjDestroy(sign);
324 HcfObjDestroy(generator);
325 HcfObjDestroy(keyPair);
326 }
327
328 // incorrect case : sign with other class (not cipher).
329 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest293, TestSize.Level0)
330 {
331 HcfResult res = HCF_SUCCESS;
332 HcfAsyKeyGenerator *generator = NULL;
333 res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
334
335 HcfSign *sign = NULL;
336 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
337 EXPECT_EQ(res, HCF_SUCCESS);
338
339 HcfBlob input;
340 res = sign->sign((HcfSign *)generator, NULL, &input);
341 EXPECT_NE(res, HCF_SUCCESS);
342
343 HcfObjDestroy(sign);
344 HcfObjDestroy(generator);
345 }
346
347 // incorrect case : update with NULL inputBlob.
348 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest294, TestSize.Level0)
349 {
350 HcfResult res = HCF_SUCCESS;
351 HcfAsyKeyGenerator *generator = NULL;
352 res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
353
354 HcfSign *sign = NULL;
355 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
356 EXPECT_EQ(res, HCF_SUCCESS);
357
358 res = sign->update(sign, NULL);
359 EXPECT_NE(res, HCF_SUCCESS);
360
361 HcfObjDestroy(sign);
362 HcfObjDestroy(generator);
363 }
364
365 // incorrect case : sign with NULL outputBlob.
366 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest295, TestSize.Level0)
367 {
368 HcfResult res = HCF_SUCCESS;
369 HcfAsyKeyGenerator *generator = NULL;
370 res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
371
372 HcfSign *sign = NULL;
373 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
374 EXPECT_EQ(res, HCF_SUCCESS);
375
376 res = sign->sign(sign, NULL, NULL);
377 EXPECT_NE(res, HCF_SUCCESS);
378
379 HcfObjDestroy(sign);
380 HcfObjDestroy(generator);
381 }
382
383
384 // correct case: sign and update
385 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest300, TestSize.Level0)
386 {
387 HcfResult res = HCF_SUCCESS;
388 uint8_t plan[] = "this is rsa verify test.";
389 HcfAsyKeyGenerator *generator = NULL;
390 res = HcfAsyKeyGeneratorCreate("RSA768|PRIMES_2", &generator);
391 HcfKeyPair *keyPair = NULL;
392 res = generator->generateKeyPair(generator, NULL, &keyPair);
393 EXPECT_EQ(res, HCF_SUCCESS);
394
395 HcfPriKey *prikey = keyPair->priKey;
396 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
397 HcfBlob verifyData = {.data = NULL, .len = 0};
398 HcfSign *sign = NULL;
399 res = HcfSignCreate("RSA768|PKCS1|SHA1", &sign);
400 EXPECT_EQ(res, HCF_SUCCESS);
401 res = sign->init(sign, NULL, prikey);
402 EXPECT_EQ(res, HCF_SUCCESS);
403 res = sign->sign(sign, &input, &verifyData);
404
405 HcfObjDestroy(sign);
406 HcfFree(verifyData.data);
407 HcfObjDestroy(keyPair);
408 HcfObjDestroy(generator);
409 }
410
411 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest310, TestSize.Level0)
412 {
413 uint8_t plan[] = "this is rsa verify test.";
414 HcfAsyKeyGenerator *generator = NULL;
415 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
416 HcfKeyPair *keyPair = NULL;
417 res = generator->generateKeyPair(generator, NULL, &keyPair);
418 EXPECT_EQ(res, HCF_SUCCESS);
419
420 HcfPriKey *prikey = keyPair->priKey;
421 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
422 HcfBlob verifyData = {.data = NULL, .len = 0};
423 HcfSign *sign = NULL;
424 res = HcfSignCreate("RSA1024|PKCS1|SHA256", &sign);
425 EXPECT_EQ(res, HCF_SUCCESS);
426 res = sign->init(sign, NULL, prikey);
427 EXPECT_EQ(res, HCF_SUCCESS);
428 res = sign->sign(sign, &input, &verifyData);
429
430 HcfObjDestroy(sign);
431 HcfFree(verifyData.data);
432 HcfObjDestroy(keyPair);
433 HcfObjDestroy(generator);
434 }
435
436 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest320, TestSize.Level0)
437 {
438 uint8_t plan[] = "this is rsa verify test.";
439 HcfAsyKeyGenerator *generator = NULL;
440 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
441 HcfKeyPair *keyPair = NULL;
442 res = generator->generateKeyPair(generator, NULL, &keyPair);
443 EXPECT_EQ(res, HCF_SUCCESS);
444
445 HcfPriKey *prikey = keyPair->priKey;
446 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
447 HcfBlob verifyData = {.data = NULL, .len = 0};
448 HcfSign *sign = NULL;
449 res = HcfSignCreate("RSA2048|PKCS1|SHA256", &sign);
450 EXPECT_EQ(res, HCF_SUCCESS);
451 res = sign->init(sign, NULL, prikey);
452 EXPECT_EQ(res, HCF_SUCCESS);
453 res = sign->sign(sign, &input, &verifyData);
454
455 HcfObjDestroy(sign);
456 HcfFree(verifyData.data);
457 HcfObjDestroy(keyPair);
458 HcfObjDestroy(generator);
459 }
460
461 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest330, TestSize.Level0)
462 {
463 uint8_t plan[] = "this is rsa verify test.";
464 HcfAsyKeyGenerator *generator = NULL;
465 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
466 HcfKeyPair *keyPair = NULL;
467 res = generator->generateKeyPair(generator, NULL, &keyPair);
468 EXPECT_EQ(res, HCF_SUCCESS);
469
470 HcfPriKey *prikey = keyPair->priKey;
471 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
472 HcfBlob verifyData = {.data = NULL, .len = 0};
473 HcfSign *sign = NULL;
474 res = HcfSignCreate("RSA4096|PKCS1|SHA256", &sign);
475 EXPECT_EQ(res, HCF_SUCCESS);
476 res = sign->init(sign, NULL, prikey);
477 EXPECT_EQ(res, HCF_SUCCESS);
478 res = sign->sign(sign, &input, &verifyData);
479
480 HcfObjDestroy(sign);
481 HcfFree(verifyData.data);
482 HcfObjDestroy(keyPair);
483 HcfObjDestroy(generator);
484 }
485
486 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest340, TestSize.Level0)
487 {
488 uint8_t plan[] = "this is rsa verify test.";
489 HcfAsyKeyGenerator *generator = NULL;
490 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
491 HcfKeyPair *keyPair = NULL;
492 res = generator->generateKeyPair(generator, NULL, &keyPair);
493 EXPECT_EQ(res, HCF_SUCCESS);
494
495 HcfPriKey *prikey = keyPair->priKey;
496 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
497 HcfBlob verifyData = {.data = NULL, .len = 0};
498 HcfSign *sign = NULL;
499 res = HcfSignCreate("RSA4096|PKCS1|SHA512", &sign);
500 EXPECT_EQ(res, HCF_SUCCESS);
501 res = sign->init(sign, NULL, prikey);
502 EXPECT_EQ(res, HCF_SUCCESS);
503 res = sign->sign(sign, &input, &verifyData);
504
505 HcfObjDestroy(sign);
506 HcfFree(verifyData.data);
507 HcfObjDestroy(keyPair);
508 HcfObjDestroy(generator);
509 }
510
511 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest350, TestSize.Level0)
512 {
513 uint8_t plan[] = "this is rsa verify test.";
514 HcfAsyKeyGenerator *generator = NULL;
515 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_2", &generator);
516 HcfKeyPair *keyPair = NULL;
517 res = generator->generateKeyPair(generator, NULL, &keyPair);
518 EXPECT_EQ(res, HCF_SUCCESS);
519
520 HcfPriKey *prikey = keyPair->priKey;
521 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
522 HcfBlob verifyData = {.data = NULL, .len = 0};
523 HcfSign *sign = NULL;
524 res = HcfSignCreate("RSA1024|PSS|SHA256|MGF1_SHA256", &sign);
525 EXPECT_EQ(res, HCF_SUCCESS);
526 res = sign->init(sign, NULL, prikey);
527 EXPECT_EQ(res, HCF_SUCCESS);
528 res = sign->sign(sign, &input, &verifyData);
529
530 HcfObjDestroy(sign);
531 HcfFree(verifyData.data);
532 HcfObjDestroy(keyPair);
533 HcfObjDestroy(generator);
534 }
535
536 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest360, TestSize.Level0)
537 {
538 uint8_t plan[] = "this is rsa verify test.";
539 HcfAsyKeyGenerator *generator = NULL;
540 HcfResult res = HcfAsyKeyGeneratorCreate("RSA2048|PRIMES_2", &generator);
541 HcfKeyPair *keyPair = NULL;
542 res = generator->generateKeyPair(generator, NULL, &keyPair);
543 EXPECT_EQ(res, HCF_SUCCESS);
544
545 HcfPriKey *prikey = keyPair->priKey;
546 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
547 HcfBlob verifyData = {.data = NULL, .len = 0};
548 HcfSign *sign = NULL;
549 res = HcfSignCreate("RSA2048|PSS|SHA256|MGF1_SHA256", &sign);
550 EXPECT_EQ(res, HCF_SUCCESS);
551 res = sign->init(sign, NULL, prikey);
552 EXPECT_EQ(res, HCF_SUCCESS);
553 res = sign->sign(sign, &input, &verifyData);
554
555 HcfObjDestroy(sign);
556 HcfFree(verifyData.data);
557 HcfObjDestroy(keyPair);
558 HcfObjDestroy(generator);
559 }
560
561 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest370, TestSize.Level0)
562 {
563 uint8_t plan[] = "this is rsa verify test.";
564 HcfAsyKeyGenerator *generator = NULL;
565 HcfResult res = HcfAsyKeyGeneratorCreate("RSA3072|PRIMES_2", &generator);
566 HcfKeyPair *keyPair = NULL;
567 res = generator->generateKeyPair(generator, NULL, &keyPair);
568 EXPECT_EQ(res, HCF_SUCCESS);
569
570 HcfPriKey *prikey = keyPair->priKey;
571 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
572 HcfBlob verifyData = {.data = NULL, .len = 0};
573 HcfSign *sign = NULL;
574 res = HcfSignCreate("RSA3072|PSS|SHA256|MGF1_SHA256", &sign);
575 EXPECT_EQ(res, HCF_SUCCESS);
576 res = sign->init(sign, NULL, prikey);
577 EXPECT_EQ(res, HCF_SUCCESS);
578 res = sign->sign(sign, &input, &verifyData);
579
580 HcfObjDestroy(sign);
581 HcfFree(verifyData.data);
582 HcfObjDestroy(keyPair);
583 HcfObjDestroy(generator);
584 }
585
586 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest380, TestSize.Level0)
587 {
588 uint8_t plan[] = "this is rsa verify test.";
589 HcfAsyKeyGenerator *generator = NULL;
590 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
591 HcfKeyPair *keyPair = NULL;
592 res = generator->generateKeyPair(generator, NULL, &keyPair);
593 EXPECT_EQ(res, HCF_SUCCESS);
594
595 HcfPriKey *prikey = keyPair->priKey;
596 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
597 HcfBlob verifyData = {.data = NULL, .len = 0};
598 HcfSign *sign = NULL;
599 res = HcfSignCreate("RSA4096|PSS|SHA256|MGF1_SHA256", &sign);
600 EXPECT_EQ(res, HCF_SUCCESS);
601 res = sign->init(sign, NULL, prikey);
602 EXPECT_EQ(res, HCF_SUCCESS);
603 res = sign->sign(sign, &input, &verifyData);
604
605 HcfObjDestroy(sign);
606 HcfFree(verifyData.data);
607 HcfObjDestroy(keyPair);
608 HcfObjDestroy(generator);
609 }
610
611 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest390, TestSize.Level0)
612 {
613 uint8_t plan[] = "this is rsa verify test.";
614 HcfAsyKeyGenerator *generator = NULL;
615 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
616 HcfKeyPair *keyPair = NULL;
617 res = generator->generateKeyPair(generator, NULL, &keyPair);
618 EXPECT_EQ(res, HCF_SUCCESS);
619
620 HcfPriKey *prikey = keyPair->priKey;
621 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
622 HcfBlob verifyData = {.data = NULL, .len = 0};
623 HcfSign *sign = NULL;
624 res = HcfSignCreate("RSA4096|PSS|SHA512|MGF1_SHA256", &sign);
625 EXPECT_EQ(res, HCF_SUCCESS);
626 res = sign->init(sign, NULL, prikey);
627 EXPECT_EQ(res, HCF_SUCCESS);
628 res = sign->sign(sign, &input, &verifyData);
629
630 HcfObjDestroy(sign);
631 HcfFree(verifyData.data);
632 HcfObjDestroy(keyPair);
633 HcfObjDestroy(generator);
634 }
635
636 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest400, TestSize.Level0)
637 {
638 uint8_t plan[] = "this is rsa verify test.";
639 HcfAsyKeyGenerator *generator = NULL;
640 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
641 HcfKeyPair *keyPair = NULL;
642 res = generator->generateKeyPair(generator, NULL, &keyPair);
643 EXPECT_EQ(res, HCF_SUCCESS);
644
645 HcfPriKey *prikey = keyPair->priKey;
646 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
647 HcfBlob verifyData = {.data = NULL, .len = 0};
648 HcfSign *sign = NULL;
649 res = HcfSignCreate("RSA4096|PSS|SHA1|MGF1_SHA256", &sign);
650 EXPECT_EQ(res, HCF_SUCCESS);
651 res = sign->init(sign, NULL, prikey);
652 EXPECT_EQ(res, HCF_SUCCESS);
653 res = sign->sign(sign, &input, &verifyData);
654
655 HcfObjDestroy(sign);
656 HcfFree(verifyData.data);
657 HcfObjDestroy(keyPair);
658 HcfObjDestroy(generator);
659 }
660
661 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest410, TestSize.Level0)
662 {
663 uint8_t plan[] = "this is rsa verify test.";
664 HcfAsyKeyGenerator *generator = NULL;
665 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
666 HcfKeyPair *keyPair = NULL;
667 res = generator->generateKeyPair(generator, NULL, &keyPair);
668 EXPECT_EQ(res, HCF_SUCCESS);
669
670 HcfPriKey *prikey = keyPair->priKey;
671 HcfBlob input = {.data = plan, .len = strlen((char *)plan)};
672 HcfBlob verifyData = {.data = NULL, .len = 0};
673 HcfSign *sign = NULL;
674 res = HcfSignCreate("RSA4096|PSS|SHA256|MGF1_MD5", &sign);
675 EXPECT_EQ(res, HCF_SUCCESS);
676 res = sign->init(sign, NULL, prikey);
677 EXPECT_EQ(res, HCF_SUCCESS);
678 res = sign->sign(sign, &input, &verifyData);
679
680 HcfObjDestroy(sign);
681 HcfFree(verifyData.data);
682 HcfObjDestroy(keyPair);
683 HcfObjDestroy(generator);
684 }
685
686 // incorrect case: double init sign
687 HWTEST_F(CryptoRsaSignTest, CryptoRsaSignTest500, TestSize.Level0)
688 {
689 HcfAsyKeyGenerator *generator = NULL;
690 HcfResult res = HcfAsyKeyGeneratorCreate("RSA4096|PRIMES_2", &generator);
691 HcfKeyPair *keyPair = NULL;
692 res = generator->generateKeyPair(generator, NULL, &keyPair);
693 EXPECT_EQ(res, HCF_SUCCESS);
694
695 HcfPriKey *prikey = keyPair->priKey;
696 HcfSign *sign = NULL;
697 res = HcfSignCreate("RSA4096|PKCS1|SHA512", &sign);
698 EXPECT_EQ(res, HCF_SUCCESS);
699
700 res = sign->init(sign, NULL, prikey);
701 EXPECT_EQ(res, HCF_SUCCESS);
702 res = sign->init(sign, NULL, prikey);
703 EXPECT_NE(res, HCF_SUCCESS);
704
705 HcfObjDestroy(sign);
706 HcfObjDestroy(keyPair);
707 HcfObjDestroy(generator);
708 }
709 }
710