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 <fstream> 18 #include <iostream> 19 #include "securec.h" 20 #include "aes_openssl.h" 21 #include "aes_common.h" 22 #include "blob.h" 23 #include "cipher.h" 24 #include "detailed_iv_params.h" 25 #include "detailed_gcm_params.h" 26 #include "detailed_ccm_params.h" 27 #include "log.h" 28 #include "memory.h" 29 #include "sym_common_defines.h" 30 #include "sym_key_generator.h" 31 #include "sm4_common.h" 32 #include "sm4_openssl.h" 33 34 using namespace std; 35 using namespace testing::ext; 36 37 namespace { 38 class CryptoSM4CfbCipherTest : public testing::Test { 39 public: SetUpTestCase()40 static void SetUpTestCase() {}; TearDownTestCase()41 static void TearDownTestCase() {}; SetUp()42 void SetUp() {}; TearDown()43 void TearDown() {}; 44 }; 45 46 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest010, TestSize.Level0) 47 { 48 int ret = 0; 49 uint8_t cipherText[128] = {0}; 50 int cipherTextLen = 128; 51 52 HcfSymKeyGenerator *generator = nullptr; 53 HcfCipher *cipher = nullptr; 54 HcfSymKey *key = nullptr; 55 56 57 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 58 if (ret != 0) { 59 LOGE("HcfSymKeyGeneratorCreate failed!"); 60 goto clearup; 61 } 62 63 ret = generator->generateSymKey(generator, &key); 64 if (ret != 0) { 65 LOGE("generateSymKey failed!"); 66 goto clearup; 67 } 68 69 ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher); 70 if (ret != 0) { 71 LOGE("HcfCipherCreate failed!"); 72 goto clearup; 73 } 74 75 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 76 if (ret != 0) { 77 LOGE("Sm4Encrypt failed! "); 78 goto clearup; 79 } 80 81 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 82 if (ret != 0) { 83 LOGE("Sm4Decrypt failed! "); 84 goto clearup; 85 } 86 87 clearup: 88 HcfObjDestroy((HcfObjectBase *)key); 89 HcfObjDestroy((HcfObjectBase *)cipher); 90 HcfObjDestroy((HcfObjectBase *)generator); 91 EXPECT_EQ(ret, 0); 92 } 93 94 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest011, TestSize.Level0) 95 { 96 int ret = 0; 97 uint8_t cipherText[128] = {0}; 98 int cipherTextLen = 128; 99 100 HcfSymKeyGenerator *generator = nullptr; 101 HcfCipher *cipher = nullptr; 102 HcfSymKey *key = nullptr; 103 104 105 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 106 if (ret != 0) { 107 LOGE("HcfSymKeyGeneratorCreate failed!"); 108 goto clearup; 109 } 110 111 ret = generator->generateSymKey(generator, &key); 112 if (ret != 0) { 113 LOGE("generateSymKey failed!"); 114 goto clearup; 115 } 116 117 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 118 if (ret != 0) { 119 LOGE("HcfCipherCreate failed!"); 120 goto clearup; 121 } 122 123 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 124 if (ret != 0) { 125 LOGE("Sm4Encrypt failed! "); 126 goto clearup; 127 } 128 129 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 130 if (ret != 0) { 131 LOGE("Sm4Decrypt failed! "); 132 goto clearup; 133 } 134 135 clearup: 136 HcfObjDestroy((HcfObjectBase *)key); 137 HcfObjDestroy((HcfObjectBase *)cipher); 138 HcfObjDestroy((HcfObjectBase *)generator); 139 EXPECT_EQ(ret, 0); 140 } 141 142 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest012, TestSize.Level0) 143 { 144 int ret = 0; 145 uint8_t cipherText[128] = {0}; 146 int cipherTextLen = 128; 147 148 HcfSymKeyGenerator *generator = nullptr; 149 HcfCipher *cipher = nullptr; 150 HcfSymKey *key = nullptr; 151 152 153 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 154 if (ret != 0) { 155 LOGE("HcfSymKeyGeneratorCreate failed!"); 156 goto clearup; 157 } 158 159 ret = generator->generateSymKey(generator, &key); 160 if (ret != 0) { 161 LOGE("generateSymKey failed!"); 162 goto clearup; 163 } 164 165 ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher); 166 if (ret != 0) { 167 LOGE("HcfCipherCreate failed!"); 168 goto clearup; 169 } 170 171 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 172 if (ret != 0) { 173 LOGE("Sm4Encrypt failed! "); 174 goto clearup; 175 } 176 177 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 178 if (ret != 0) { 179 LOGE("Sm4Decrypt failed! "); 180 goto clearup; 181 } 182 183 clearup: 184 HcfObjDestroy((HcfObjectBase *)key); 185 HcfObjDestroy((HcfObjectBase *)cipher); 186 HcfObjDestroy((HcfObjectBase *)generator); 187 EXPECT_EQ(ret, 0); 188 } 189 190 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest013, TestSize.Level0) 191 { 192 int ret = 0; 193 uint8_t cipherText[128] = {0}; 194 int cipherTextLen = 128; 195 196 HcfSymKeyGenerator *generator = nullptr; 197 HcfCipher *cipher = nullptr; 198 HcfSymKey *key = nullptr; 199 200 201 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 202 if (ret != 0) { 203 LOGE("HcfSymKeyGeneratorCreate failed!"); 204 goto clearup; 205 } 206 207 ret = generator->generateSymKey(generator, &key); 208 if (ret != 0) { 209 LOGE("generateSymKey failed!"); 210 goto clearup; 211 } 212 213 ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher); 214 if (ret != 0) { 215 LOGE("HcfCipherCreate failed!"); 216 goto clearup; 217 } 218 219 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 220 if (ret != 0) { 221 LOGE("Sm4Encrypt failed! "); 222 goto clearup; 223 } 224 225 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 226 if (ret != 0) { 227 LOGE("Sm4Decrypt failed! "); 228 goto clearup; 229 } 230 231 clearup: 232 HcfObjDestroy((HcfObjectBase *)key); 233 HcfObjDestroy((HcfObjectBase *)cipher); 234 HcfObjDestroy((HcfObjectBase *)generator); 235 EXPECT_EQ(ret, 0); 236 } 237 238 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest014, TestSize.Level0) 239 { 240 int ret = 0; 241 uint8_t cipherText[128] = {0}; 242 int cipherTextLen = 128; 243 244 HcfSymKeyGenerator *generator = nullptr; 245 HcfCipher *cipher = nullptr; 246 HcfSymKey *key = nullptr; 247 248 249 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 250 if (ret != 0) { 251 LOGE("HcfSymKeyGeneratorCreate failed!"); 252 goto clearup; 253 } 254 255 ret = generator->generateSymKey(generator, &key); 256 if (ret != 0) { 257 LOGE("generateSymKey failed!"); 258 goto clearup; 259 } 260 261 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 262 if (ret != 0) { 263 LOGE("HcfCipherCreate failed!"); 264 goto clearup; 265 } 266 267 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 268 if (ret != 0) { 269 LOGE("Sm4Encrypt failed! "); 270 goto clearup; 271 } 272 273 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 274 if (ret != 0) { 275 LOGE("Sm4Decrypt failed! "); 276 goto clearup; 277 } 278 279 clearup: 280 HcfObjDestroy((HcfObjectBase *)key); 281 HcfObjDestroy((HcfObjectBase *)cipher); 282 HcfObjDestroy((HcfObjectBase *)generator); 283 EXPECT_EQ(ret, 0); 284 } 285 286 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest015, TestSize.Level0) 287 { 288 int ret = 0; 289 uint8_t cipherText[128] = {0}; 290 int cipherTextLen = 128; 291 292 HcfSymKeyGenerator *generator = nullptr; 293 HcfCipher *cipher = nullptr; 294 HcfSymKey *key = nullptr; 295 296 297 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 298 if (ret != 0) { 299 LOGE("HcfSymKeyGeneratorCreate failed!"); 300 goto clearup; 301 } 302 303 ret = generator->generateSymKey(generator, &key); 304 if (ret != 0) { 305 LOGE("generateSymKey failed!"); 306 goto clearup; 307 } 308 309 ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher); 310 if (ret != 0) { 311 LOGE("HcfCipherCreate failed!"); 312 goto clearup; 313 } 314 315 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 316 if (ret != 0) { 317 LOGE("Sm4Encrypt failed! "); 318 goto clearup; 319 } 320 321 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 322 if (ret != 0) { 323 LOGE("Sm4Decrypt failed! "); 324 goto clearup; 325 } 326 327 clearup: 328 HcfObjDestroy((HcfObjectBase *)key); 329 HcfObjDestroy((HcfObjectBase *)cipher); 330 HcfObjDestroy((HcfObjectBase *)generator); 331 EXPECT_EQ(ret, 0); 332 } 333 334 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest028, TestSize.Level0) 335 { 336 int ret = 0; 337 uint8_t cipherText[128] = {0}; 338 int cipherTextLen = 128; 339 340 HcfSymKeyGenerator *generator = nullptr; 341 HcfCipher *cipher = nullptr; 342 HcfSymKey *key = nullptr; 343 344 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 345 if (ret != 0) { 346 LOGE("HcfSymKeyGeneratorCreate failed!"); 347 goto clearup; 348 } 349 350 ret = generator->generateSymKey(generator, &key); 351 if (ret != 0) { 352 LOGE("generateSymKey failed!"); 353 goto clearup; 354 } 355 356 ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher); 357 if (ret != 0) { 358 LOGE("HcfCipherCreate failed!"); 359 goto clearup; 360 } 361 362 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 363 if (ret != 0) { 364 LOGE("Sm4NoUpdateEncrypt failed! "); 365 goto clearup; 366 } 367 368 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 369 if (ret != 0) { 370 LOGE("Sm4NoUpdateDecrypt failed! "); 371 goto clearup; 372 } 373 374 clearup: 375 HcfObjDestroy((HcfObjectBase *)key); 376 HcfObjDestroy((HcfObjectBase *)cipher); 377 HcfObjDestroy((HcfObjectBase *)generator); 378 EXPECT_EQ(ret, 0); 379 } 380 381 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest029, TestSize.Level0) 382 { 383 int ret = 0; 384 uint8_t cipherText[128] = {0}; 385 int cipherTextLen = 128; 386 387 HcfSymKeyGenerator *generator = nullptr; 388 HcfCipher *cipher = nullptr; 389 HcfSymKey *key = nullptr; 390 391 392 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 393 if (ret != 0) { 394 LOGE("HcfSymKeyGeneratorCreate failed!"); 395 goto clearup; 396 } 397 398 ret = generator->generateSymKey(generator, &key); 399 if (ret != 0) { 400 LOGE("generateSymKey failed!"); 401 goto clearup; 402 } 403 404 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 405 if (ret != 0) { 406 LOGE("HcfCipherCreate failed!"); 407 goto clearup; 408 } 409 410 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 411 if (ret != 0) { 412 LOGE("Sm4NoUpdateEncrypt failed! "); 413 goto clearup; 414 } 415 416 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 417 if (ret != 0) { 418 LOGE("Sm4NoUpdateDecrypt failed! "); 419 goto clearup; 420 } 421 422 clearup: 423 HcfObjDestroy((HcfObjectBase *)key); 424 HcfObjDestroy((HcfObjectBase *)cipher); 425 HcfObjDestroy((HcfObjectBase *)generator); 426 EXPECT_EQ(ret, 0); 427 } 428 429 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest030, TestSize.Level0) 430 { 431 int ret = 0; 432 uint8_t cipherText[128] = {0}; 433 int cipherTextLen = 128; 434 435 HcfSymKeyGenerator *generator = nullptr; 436 HcfCipher *cipher = nullptr; 437 HcfSymKey *key = nullptr; 438 439 440 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 441 if (ret != 0) { 442 LOGE("HcfSymKeyGeneratorCreate failed!"); 443 goto clearup; 444 } 445 446 ret = generator->generateSymKey(generator, &key); 447 if (ret != 0) { 448 LOGE("generateSymKey failed!"); 449 goto clearup; 450 } 451 452 ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher); 453 if (ret != 0) { 454 LOGE("HcfCipherCreate failed!"); 455 goto clearup; 456 } 457 458 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 459 if (ret != 0) { 460 LOGE("Sm4NoUpdateEncrypt failed! "); 461 goto clearup; 462 } 463 464 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 465 if (ret != 0) { 466 LOGE("Sm4NoUpdateDecrypt failed! "); 467 goto clearup; 468 } 469 470 clearup: 471 HcfObjDestroy((HcfObjectBase *)key); 472 HcfObjDestroy((HcfObjectBase *)cipher); 473 HcfObjDestroy((HcfObjectBase *)generator); 474 EXPECT_EQ(ret, 0); 475 } 476 477 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest031, TestSize.Level0) 478 { 479 int ret = 0; 480 uint8_t cipherText[128] = {0}; 481 int cipherTextLen = 128; 482 483 HcfSymKeyGenerator *generator = nullptr; 484 HcfCipher *cipher = nullptr; 485 HcfSymKey *key = nullptr; 486 487 488 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 489 if (ret != 0) { 490 LOGE("HcfSymKeyGeneratorCreate failed!"); 491 goto clearup; 492 } 493 494 ret = generator->generateSymKey(generator, &key); 495 if (ret != 0) { 496 LOGE("generateSymKey failed!"); 497 goto clearup; 498 } 499 500 ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher); 501 if (ret != 0) { 502 LOGE("HcfCipherCreate failed!"); 503 goto clearup; 504 } 505 506 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 507 if (ret != 0) { 508 LOGE("Sm4NoUpdateEncrypt failed! "); 509 goto clearup; 510 } 511 512 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 513 if (ret != 0) { 514 LOGE("Sm4NoUpdateDecrypt failed! "); 515 goto clearup; 516 } 517 518 clearup: 519 HcfObjDestroy((HcfObjectBase *)key); 520 HcfObjDestroy((HcfObjectBase *)cipher); 521 HcfObjDestroy((HcfObjectBase *)generator); 522 EXPECT_EQ(ret, 0); 523 } 524 525 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest032, TestSize.Level0) 526 { 527 int ret = 0; 528 uint8_t cipherText[128] = {0}; 529 int cipherTextLen = 128; 530 531 HcfSymKeyGenerator *generator = nullptr; 532 HcfCipher *cipher = nullptr; 533 HcfSymKey *key = nullptr; 534 535 536 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 537 if (ret != 0) { 538 LOGE("HcfSymKeyGeneratorCreate failed!"); 539 goto clearup; 540 } 541 542 ret = generator->generateSymKey(generator, &key); 543 if (ret != 0) { 544 LOGE("generateSymKey failed!"); 545 goto clearup; 546 } 547 548 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 549 if (ret != 0) { 550 LOGE("HcfCipherCreate failed!"); 551 goto clearup; 552 } 553 554 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 555 if (ret != 0) { 556 LOGE("Sm4NoUpdateEncrypt failed! "); 557 goto clearup; 558 } 559 560 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 561 if (ret != 0) { 562 LOGE("Sm4NoUpdateDecrypt failed! "); 563 goto clearup; 564 } 565 566 clearup: 567 HcfObjDestroy((HcfObjectBase *)key); 568 HcfObjDestroy((HcfObjectBase *)cipher); 569 HcfObjDestroy((HcfObjectBase *)generator); 570 EXPECT_EQ(ret, 0); 571 } 572 573 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest033, TestSize.Level0) 574 { 575 int ret = 0; 576 uint8_t cipherText[128] = {0}; 577 int cipherTextLen = 128; 578 579 HcfSymKeyGenerator *generator = nullptr; 580 HcfCipher *cipher = nullptr; 581 HcfSymKey *key = nullptr; 582 583 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 584 if (ret != 0) { 585 LOGE("HcfSymKeyGeneratorCreate failed!"); 586 goto clearup; 587 } 588 589 ret = generator->generateSymKey(generator, &key); 590 if (ret != 0) { 591 LOGE("generateSymKey failed!"); 592 goto clearup; 593 } 594 595 ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher); 596 if (ret != 0) { 597 LOGE("HcfCipherCreate failed!"); 598 goto clearup; 599 } 600 601 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 602 if (ret != 0) { 603 LOGE("Sm4NoUpdateEncrypt failed! "); 604 goto clearup; 605 } 606 607 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 608 if (ret != 0) { 609 LOGE("Sm4NoUpdateDecrypt failed! "); 610 goto clearup; 611 } 612 613 clearup: 614 HcfObjDestroy((HcfObjectBase *)key); 615 HcfObjDestroy((HcfObjectBase *)cipher); 616 HcfObjDestroy((HcfObjectBase *)generator); 617 EXPECT_EQ(ret, 0); 618 } 619 620 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest040, TestSize.Level0) 621 { 622 int ret = 0; 623 HcfCipher *cipher = nullptr; 624 const char *cipherName = "SM4_128|CFB|NoPadding"; 625 const char *retAlgo = nullptr; 626 ret = HcfCipherCreate(cipherName, &cipher); 627 if (ret != 0) { 628 LOGE("HcfCipherCreate failed!"); 629 goto CLEAR_UP; 630 } 631 632 retAlgo = cipher->getAlgorithm(nullptr); 633 if (retAlgo == nullptr) { 634 LOGE("cipher getAlgorithm failed!"); 635 ret = HCF_ERR_CRYPTO_OPERATION; 636 } 637 638 CLEAR_UP: 639 HcfObjDestroy(cipher); 640 EXPECT_NE(ret, 0); 641 } 642 643 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest041, TestSize.Level0) 644 { 645 int ret = 0; 646 HcfCipher *cipher = nullptr; 647 HcfSymKeyGenerator *generator = nullptr; 648 const char *cipherName = "SM4_128|CFB|NoPadding"; 649 const char *retAlgo = nullptr; 650 651 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 652 if (ret != 0) { 653 LOGE("HcfSymKeyGeneratorCreate failed!"); 654 goto CLEAR_UP; 655 } 656 657 ret = HcfCipherCreate(cipherName, &cipher); 658 if (ret != 0) { 659 LOGE("HcfCipherCreate failed!"); 660 goto CLEAR_UP; 661 } 662 663 retAlgo = cipher->getAlgorithm(reinterpret_cast<HcfCipher *>(generator)); 664 if (retAlgo == nullptr) { 665 LOGE("cipher getAlgorithm failed!"); 666 ret = HCF_ERR_CRYPTO_OPERATION; 667 } 668 669 CLEAR_UP: 670 HcfObjDestroy(generator); 671 HcfObjDestroy(cipher); 672 EXPECT_NE(ret, 0); 673 } 674 675 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest042, TestSize.Level0) 676 { 677 int ret = 0; 678 HcfCipher *cipher = nullptr; 679 680 ret = HcfCipherCreate("SM3|CFB|NoPadding", &cipher); 681 if (ret != 0) { 682 LOGE("HcfCipherCreate failed! Should not select SM3 for CFB generator."); 683 } 684 685 HcfObjDestroy(cipher); 686 EXPECT_NE(ret, 0); 687 } 688 689 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest043, TestSize.Level0) 690 { 691 int ret = 0; 692 HcfCipher *cipher = nullptr; 693 694 // not allow '|' without content, because findAbility will fail for "" input 695 ret = HcfCipherCreate("SM4_128|CFB|", &cipher); 696 if (ret != 0) { 697 LOGE("HcfCipherCreate failed! Should select padding mode for SM4_128 generator."); 698 } 699 700 HcfObjDestroy(cipher); 701 EXPECT_NE(ret, 0); 702 } 703 704 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest047, TestSize.Level0) 705 { 706 int ret = 0; 707 708 ret = HcfCipherCreate(nullptr, nullptr); 709 if (ret != 0) { 710 LOGE("HcfCipherCreate failed! Should not select SM3 for CFB generator."); 711 } 712 713 EXPECT_NE(ret, 0); 714 } 715 716 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest050, TestSize.Level0) 717 { 718 int ret = 0; 719 uint8_t aad[8] = {0}; 720 uint8_t tag[12] = {0}; 721 uint8_t iv[7] = {0}; 722 uint8_t cipherText[128] = {0}; 723 int cipherTextLen = 128; 724 725 HcfCipher *cipher = nullptr; 726 HcfSymKey *key = nullptr; 727 HcfCcmParamsSpec spec = {}; 728 spec.aad.data = aad; 729 spec.aad.len = sizeof(aad); 730 spec.tag.data = tag; 731 spec.tag.len = sizeof(tag); 732 spec.iv.data = iv; 733 spec.iv.len = sizeof(iv); 734 735 ret = GenerateSymKeyForSm4("SM4_128", &key); 736 if (ret != 0) { 737 LOGE("generateSymKey failed!"); 738 goto CLEAR_UP; 739 } 740 741 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 742 if (ret != 0) { 743 LOGE("HcfCipherCreate failed!"); 744 goto CLEAR_UP; 745 } 746 747 ret = Sm4Encrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); 748 if (ret != 0) { 749 LOGE("Sm4Encrypt failed!"); 750 goto CLEAR_UP; 751 } 752 753 (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); 754 755 cipherTextLen -= 12; 756 757 ret = Sm4Decrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); 758 if (ret != 0) { 759 LOGE("Sm4Decrypt failed!"); 760 goto CLEAR_UP; 761 } 762 763 CLEAR_UP: 764 HcfObjDestroy((HcfObjectBase *)key); 765 HcfObjDestroy((HcfObjectBase *)cipher); 766 EXPECT_NE(ret, 0); 767 } 768 769 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest051, TestSize.Level0) 770 { 771 int ret = 0; 772 HcfCipher *cipher = nullptr; 773 const char *cipherName = "SM4_128|CFB|NoPadding"; 774 const char *retAlgo = nullptr; 775 ret = HcfCipherCreate(cipherName, &cipher); 776 if (ret != 0) { 777 LOGE("HcfCipherCreate failed!"); 778 goto CLEAR_UP; 779 } 780 781 retAlgo = cipher->getAlgorithm(cipher); 782 if (retAlgo == nullptr) { 783 LOGE("cipher getAlgorithm failed!"); 784 ret = HCF_ERR_CRYPTO_OPERATION; 785 goto CLEAR_UP; 786 } 787 788 ret = strcmp(retAlgo, cipherName); 789 if (ret != 0) { 790 LOGE("cipher getAlgorithm failed!"); 791 } 792 CLEAR_UP: 793 HcfObjDestroy(cipher); 794 EXPECT_EQ(ret, 0); 795 } 796 797 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest082, TestSize.Level0) 798 { 799 int ret = 0; 800 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 801 int cipherTextLen = CIPHER_TEXT_LEN; 802 HcfCipher *cipher = nullptr; 803 HcfSymKey *key = nullptr; 804 805 ret = GenerateSymKeyForSm4("AES256", &key); 806 if (ret != 0) { 807 LOGE("GenerateSymKey failed!"); 808 goto CLEAR_UP; 809 } 810 811 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 812 if (ret != 0) { 813 LOGE("HcfCipherCreate failed!"); 814 goto CLEAR_UP; 815 } 816 817 // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key. 818 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 819 if (ret != 0) { 820 LOGE("AesEncrypt failed! %d", ret); 821 goto CLEAR_UP; 822 } 823 824 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 825 if (ret != 0) { 826 LOGE("AesDecrypt failed! %d", ret); 827 } 828 829 CLEAR_UP: 830 HcfObjDestroy(key); 831 HcfObjDestroy(cipher); 832 EXPECT_NE(ret, 0); 833 } 834 835 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest083, TestSize.Level0) 836 { 837 int ret = 0; 838 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 839 int cipherTextLen = CIPHER_TEXT_LEN; 840 HcfCipher *cipher = nullptr; 841 HcfSymKey *key = nullptr; 842 843 ret = GenerateSymKeyForSm4("AES256", &key); 844 if (ret != 0) { 845 LOGE("GenerateSymKey failed!"); 846 goto CLEAR_UP; 847 } 848 849 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 850 if (ret != 0) { 851 LOGE("HcfCipherCreate failed!"); 852 goto CLEAR_UP; 853 } 854 855 // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key. 856 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 857 if (ret != 0) { 858 LOGE("AesEncrypt failed! %d", ret); 859 goto CLEAR_UP; 860 } 861 862 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 863 if (ret != 0) { 864 LOGE("AesDecrypt failed! %d", ret); 865 } 866 867 CLEAR_UP: 868 HcfObjDestroy(key); 869 HcfObjDestroy(cipher); 870 EXPECT_NE(ret, 0); 871 } 872 }