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