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 21 #include "aes_common.h" 22 #include "aes_openssl.h" 23 #include "blob.h" 24 #include "cipher.h" 25 #include "detailed_iv_params.h" 26 #include "detailed_gcm_params.h" 27 #include "detailed_ccm_params.h" 28 #include "log.h" 29 #include "memory.h" 30 #include "sym_common_defines.h" 31 #include "sym_key_generator.h" 32 33 using namespace std; 34 using namespace testing::ext; 35 36 namespace { 37 class CryptoAesCfbCipherTest : public testing::Test { 38 public: SetUpTestCase()39 static void SetUpTestCase() {}; TearDownTestCase()40 static void TearDownTestCase() {}; SetUp()41 void SetUp() {}; TearDown()42 void TearDown() {}; 43 }; 44 45 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest001, TestSize.Level0) 46 { 47 int ret = 0; 48 uint8_t iv[16] = {0}; 49 uint8_t cipherText[128] = {0}; 50 int cipherTextLen = 128; 51 52 HcfIvParamsSpec ivSpec = {}; 53 HcfSymKeyGenerator *generator = nullptr; 54 HcfCipher *cipher = nullptr; 55 HcfSymKey *key = nullptr; 56 ivSpec.iv.data = iv; 57 ivSpec.iv.len = 16; 58 59 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 60 if (ret != 0) { 61 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 62 goto CLEAR_UP; 63 } 64 65 ret = generator->generateSymKey(generator, &key); 66 if (ret != 0) { 67 LOGE("generateSymKey failed!"); 68 goto CLEAR_UP; 69 } 70 71 ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); 72 if (ret != 0) { 73 LOGE("HcfCipherCreate failed!"); 74 goto CLEAR_UP; 75 } 76 77 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 78 if (ret != 0) { 79 LOGE("AesEncrypt failed! %d", ret); 80 goto CLEAR_UP; 81 } 82 83 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 84 if (ret != 0) { 85 LOGE("AesDecrypt failed! %d", ret); 86 goto CLEAR_UP; 87 } 88 89 CLEAR_UP: 90 HcfObjDestroy((HcfObjectBase *)key); 91 HcfObjDestroy((HcfObjectBase *)cipher); 92 HcfObjDestroy((HcfObjectBase *)generator); 93 EXPECT_EQ(ret, 0); 94 } 95 96 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest002, TestSize.Level0) 97 { 98 int ret = 0; 99 uint8_t iv[16] = {0}; 100 uint8_t cipherText[128] = {0}; 101 int cipherTextLen = 128; 102 103 HcfIvParamsSpec ivSpec = {}; 104 HcfSymKeyGenerator *generator = nullptr; 105 HcfCipher *cipher = nullptr; 106 HcfSymKey *key = nullptr; 107 ivSpec.iv.data = iv; 108 ivSpec.iv.len = 16; 109 110 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 111 if (ret != 0) { 112 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 113 goto CLEAR_UP; 114 } 115 116 ret = generator->generateSymKey(generator, &key); 117 if (ret != 0) { 118 LOGE("generateSymKey failed!"); 119 goto CLEAR_UP; 120 } 121 122 ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher); 123 if (ret != 0) { 124 LOGE("HcfCipherCreate failed!"); 125 goto CLEAR_UP; 126 } 127 128 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 129 if (ret != 0) { 130 LOGE("AesEncrypt failed! %d", ret); 131 goto CLEAR_UP; 132 } 133 134 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 135 if (ret != 0) { 136 LOGE("AesDecrypt failed! %d", ret); 137 goto CLEAR_UP; 138 } 139 140 CLEAR_UP: 141 HcfObjDestroy((HcfObjectBase *)key); 142 HcfObjDestroy((HcfObjectBase *)cipher); 143 HcfObjDestroy((HcfObjectBase *)generator); 144 EXPECT_EQ(ret, 0); 145 } 146 147 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest003, TestSize.Level0) 148 { 149 int ret = 0; 150 uint8_t iv[16] = {0}; 151 uint8_t cipherText[128] = {0}; 152 int cipherTextLen = 128; 153 154 HcfIvParamsSpec ivSpec = {}; 155 HcfSymKeyGenerator *generator = nullptr; 156 HcfCipher *cipher = nullptr; 157 HcfSymKey *key = nullptr; 158 ivSpec.iv.data = iv; 159 ivSpec.iv.len = 16; 160 161 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 162 if (ret != 0) { 163 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 164 goto CLEAR_UP; 165 } 166 167 ret = generator->generateSymKey(generator, &key); 168 if (ret != 0) { 169 LOGE("generateSymKey failed!"); 170 goto CLEAR_UP; 171 } 172 173 ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher); 174 if (ret != 0) { 175 LOGE("HcfCipherCreate failed!"); 176 goto CLEAR_UP; 177 } 178 179 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 180 if (ret != 0) { 181 LOGE("AesEncrypt failed! %d", ret); 182 goto CLEAR_UP; 183 } 184 185 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 186 if (ret != 0) { 187 LOGE("AesDecrypt failed! %d", ret); 188 goto CLEAR_UP; 189 } 190 191 CLEAR_UP: 192 HcfObjDestroy((HcfObjectBase *)key); 193 HcfObjDestroy((HcfObjectBase *)cipher); 194 HcfObjDestroy((HcfObjectBase *)generator); 195 EXPECT_EQ(ret, 0); 196 } 197 198 199 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest004, TestSize.Level0) 200 { 201 int ret = 0; 202 uint8_t iv[16] = {0}; 203 uint8_t cipherText[128] = {0}; 204 int cipherTextLen = 128; 205 206 HcfIvParamsSpec ivSpec = {}; 207 HcfSymKeyGenerator *generator = nullptr; 208 HcfCipher *cipher = nullptr; 209 HcfSymKey *key = nullptr; 210 ivSpec.iv.data = iv; 211 ivSpec.iv.len = 16; 212 213 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 214 if (ret != 0) { 215 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 216 goto CLEAR_UP; 217 } 218 219 ret = generator->generateSymKey(generator, &key); 220 if (ret != 0) { 221 LOGE("generateSymKey failed!"); 222 goto CLEAR_UP; 223 } 224 225 ret = HcfCipherCreate("AES128|CFB1|NoPadding", &cipher); 226 if (ret != 0) { 227 LOGE("HcfCipherCreate failed!"); 228 goto CLEAR_UP; 229 } 230 231 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 232 if (ret != 0) { 233 LOGE("AesEncrypt failed! %d", ret); 234 goto CLEAR_UP; 235 } 236 237 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 238 if (ret != 0) { 239 LOGE("AesDecrypt failed! %d", ret); 240 goto CLEAR_UP; 241 } 242 243 CLEAR_UP: 244 HcfObjDestroy((HcfObjectBase *)key); 245 HcfObjDestroy((HcfObjectBase *)cipher); 246 HcfObjDestroy((HcfObjectBase *)generator); 247 EXPECT_EQ(ret, 0); 248 } 249 250 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest005, TestSize.Level0) 251 { 252 int ret = 0; 253 uint8_t iv[16] = {0}; 254 uint8_t cipherText[128] = {0}; 255 int cipherTextLen = 128; 256 257 HcfIvParamsSpec ivSpec = {}; 258 HcfSymKeyGenerator *generator = nullptr; 259 HcfCipher *cipher = nullptr; 260 HcfSymKey *key = nullptr; 261 ivSpec.iv.data = iv; 262 ivSpec.iv.len = 16; 263 264 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 265 if (ret != 0) { 266 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 267 goto CLEAR_UP; 268 } 269 270 ret = generator->generateSymKey(generator, &key); 271 if (ret != 0) { 272 LOGE("generateSymKey failed!"); 273 goto CLEAR_UP; 274 } 275 276 ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher); 277 if (ret != 0) { 278 LOGE("HcfCipherCreate failed!"); 279 goto CLEAR_UP; 280 } 281 282 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 283 if (ret != 0) { 284 LOGE("AesEncrypt failed! %d", ret); 285 goto CLEAR_UP; 286 } 287 288 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 289 if (ret != 0) { 290 LOGE("AesDecrypt failed! %d", ret); 291 goto CLEAR_UP; 292 } 293 294 CLEAR_UP: 295 HcfObjDestroy((HcfObjectBase *)key); 296 HcfObjDestroy((HcfObjectBase *)cipher); 297 HcfObjDestroy((HcfObjectBase *)generator); 298 EXPECT_EQ(ret, 0); 299 } 300 301 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest006, TestSize.Level0) 302 { 303 int ret = 0; 304 uint8_t iv[16] = {0}; 305 uint8_t cipherText[128] = {0}; 306 int cipherTextLen = 128; 307 308 HcfIvParamsSpec ivSpec = {}; 309 HcfSymKeyGenerator *generator = nullptr; 310 HcfCipher *cipher = nullptr; 311 HcfSymKey *key = nullptr; 312 ivSpec.iv.data = iv; 313 ivSpec.iv.len = 16; 314 315 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 316 if (ret != 0) { 317 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 318 goto CLEAR_UP; 319 } 320 321 ret = generator->generateSymKey(generator, &key); 322 if (ret != 0) { 323 LOGE("generateSymKey failed!"); 324 } 325 326 ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 327 if (ret != 0) { 328 LOGE("HcfCipherCreate failed!"); 329 goto CLEAR_UP; 330 } 331 332 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 333 if (ret != 0) { 334 LOGE("AesEncrypt failed! %d", ret); 335 goto CLEAR_UP; 336 } 337 338 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 339 if (ret != 0) { 340 LOGE("AesDecrypt failed! %d", ret); 341 goto CLEAR_UP; 342 } 343 344 CLEAR_UP: 345 HcfObjDestroy((HcfObjectBase *)key); 346 HcfObjDestroy((HcfObjectBase *)cipher); 347 HcfObjDestroy((HcfObjectBase *)generator); 348 EXPECT_EQ(ret, 0); 349 } 350 351 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest007, TestSize.Level0) 352 { 353 int ret = 0; 354 uint8_t iv[16] = {0}; 355 uint8_t cipherText[128] = {0}; 356 int cipherTextLen = 128; 357 358 HcfIvParamsSpec ivSpec = {}; 359 HcfSymKeyGenerator *generator = nullptr; 360 HcfCipher *cipher = nullptr; 361 HcfSymKey *key = nullptr; 362 ivSpec.iv.data = iv; 363 ivSpec.iv.len = 16; 364 365 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 366 if (ret != 0) { 367 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 368 goto CLEAR_UP; 369 } 370 371 ret = generator->generateSymKey(generator, &key); 372 if (ret != 0) { 373 LOGE("generateSymKey failed!"); 374 } 375 376 ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit 377 if (ret != 0) { 378 LOGE("HcfCipherCreate failed!"); 379 goto CLEAR_UP; 380 } 381 382 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 383 if (ret != 0) { 384 LOGE("AesEncrypt failed! %d", ret); 385 goto CLEAR_UP; 386 } 387 388 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 389 if (ret != 0) { 390 LOGE("AesDecrypt failed! %d", ret); 391 goto CLEAR_UP; 392 } 393 394 CLEAR_UP: 395 HcfObjDestroy((HcfObjectBase *)key); 396 HcfObjDestroy((HcfObjectBase *)cipher); 397 HcfObjDestroy((HcfObjectBase *)generator); 398 EXPECT_EQ(ret, 0); 399 } 400 401 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest008, TestSize.Level0) 402 { 403 int ret = 0; 404 uint8_t iv[16] = {0}; 405 uint8_t cipherText[128] = {0}; 406 int cipherTextLen = 128; 407 408 HcfIvParamsSpec ivSpec = {}; 409 HcfSymKeyGenerator *generator = nullptr; 410 HcfCipher *cipher = nullptr; 411 HcfSymKey *key = nullptr; 412 ivSpec.iv.data = iv; 413 ivSpec.iv.len = 16; 414 415 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 416 if (ret != 0) { 417 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 418 goto CLEAR_UP; 419 } 420 421 ret = generator->generateSymKey(generator, &key); 422 if (ret != 0) { 423 LOGE("generateSymKey failed!"); 424 } 425 426 ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 427 if (ret != 0) { 428 LOGE("HcfCipherCreate failed!"); 429 goto CLEAR_UP; 430 } 431 432 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 433 if (ret != 0) { 434 LOGE("AesEncrypt failed! %d", ret); 435 goto CLEAR_UP; 436 } 437 438 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 439 if (ret != 0) { 440 LOGE("AesDecrypt failed! %d", ret); 441 goto CLEAR_UP; 442 } 443 444 CLEAR_UP: 445 HcfObjDestroy((HcfObjectBase *)key); 446 HcfObjDestroy((HcfObjectBase *)cipher); 447 HcfObjDestroy((HcfObjectBase *)generator); 448 EXPECT_EQ(ret, 0); 449 } 450 451 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest009, TestSize.Level0) 452 { 453 int ret = 0; 454 uint8_t iv[16] = {0}; 455 uint8_t cipherText[128] = {0}; 456 int cipherTextLen = 128; 457 458 HcfIvParamsSpec ivSpec = {}; 459 HcfSymKeyGenerator *generator = nullptr; 460 HcfCipher *cipher = nullptr; 461 HcfSymKey *key = nullptr; 462 ivSpec.iv.data = iv; 463 ivSpec.iv.len = 16; 464 465 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 466 if (ret != 0) { 467 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 468 goto CLEAR_UP; 469 } 470 471 ret = generator->generateSymKey(generator, &key); 472 if (ret != 0) { 473 LOGE("generateSymKey failed!"); 474 } 475 476 ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 477 if (ret != 0) { 478 LOGE("HcfCipherCreate failed!"); 479 goto CLEAR_UP; 480 } 481 482 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 483 if (ret != 0) { 484 LOGE("AesEncrypt failed! %d", ret); 485 goto CLEAR_UP; 486 } 487 488 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 489 if (ret != 0) { 490 LOGE("AesDecrypt failed! %d", ret); 491 goto CLEAR_UP; 492 } 493 494 CLEAR_UP: 495 HcfObjDestroy((HcfObjectBase *)key); 496 HcfObjDestroy((HcfObjectBase *)cipher); 497 HcfObjDestroy((HcfObjectBase *)generator); 498 EXPECT_EQ(ret, 0); 499 } 500 501 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest010, TestSize.Level0) 502 { 503 int ret = 0; 504 uint8_t iv[16] = {0}; 505 uint8_t cipherText[128] = {0}; 506 int cipherTextLen = 128; 507 508 HcfIvParamsSpec ivSpec = {}; 509 HcfSymKeyGenerator *generator = nullptr; 510 HcfCipher *cipher = nullptr; 511 HcfSymKey *key = nullptr; 512 ivSpec.iv.data = iv; 513 ivSpec.iv.len = 16; 514 515 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 516 if (ret != 0) { 517 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 518 goto CLEAR_UP; 519 } 520 521 ret = generator->generateSymKey(generator, &key); 522 if (ret != 0) { 523 LOGE("generateSymKey failed!"); 524 } 525 526 ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit 527 if (ret != 0) { 528 LOGE("HcfCipherCreate failed!"); 529 goto CLEAR_UP; 530 } 531 532 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 533 if (ret != 0) { 534 LOGE("AesEncrypt failed! %d", ret); 535 goto CLEAR_UP; 536 } 537 538 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 539 if (ret != 0) { 540 LOGE("AesDecrypt failed! %d", ret); 541 goto CLEAR_UP; 542 } 543 544 CLEAR_UP: 545 HcfObjDestroy((HcfObjectBase *)key); 546 HcfObjDestroy((HcfObjectBase *)cipher); 547 HcfObjDestroy((HcfObjectBase *)generator); 548 EXPECT_EQ(ret, 0); 549 } 550 551 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest011, TestSize.Level0) 552 { 553 int ret = 0; 554 uint8_t iv[16] = {0}; 555 uint8_t cipherText[128] = {0}; 556 int cipherTextLen = 128; 557 558 HcfIvParamsSpec ivSpec = {}; 559 HcfSymKeyGenerator *generator = nullptr; 560 HcfCipher *cipher = nullptr; 561 HcfSymKey *key = nullptr; 562 ivSpec.iv.data = iv; 563 ivSpec.iv.len = 16; 564 565 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 566 if (ret != 0) { 567 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 568 goto CLEAR_UP; 569 } 570 571 ret = generator->generateSymKey(generator, &key); 572 if (ret != 0) { 573 LOGE("generateSymKey failed!"); 574 } 575 576 ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 577 if (ret != 0) { 578 LOGE("HcfCipherCreate failed!"); 579 goto CLEAR_UP; 580 } 581 582 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 583 if (ret != 0) { 584 LOGE("AesEncrypt failed! %d", ret); 585 goto CLEAR_UP; 586 } 587 588 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 589 if (ret != 0) { 590 LOGE("AesDecrypt failed! %d", ret); 591 goto CLEAR_UP; 592 } 593 594 CLEAR_UP: 595 HcfObjDestroy((HcfObjectBase *)key); 596 HcfObjDestroy((HcfObjectBase *)cipher); 597 HcfObjDestroy((HcfObjectBase *)generator); 598 EXPECT_EQ(ret, 0); 599 } 600 601 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest012, TestSize.Level0) 602 { 603 int ret = 0; 604 uint8_t iv[16] = {0}; 605 uint8_t cipherText[128] = {0}; 606 int cipherTextLen = 128; 607 608 HcfIvParamsSpec ivSpec = {}; 609 HcfSymKeyGenerator *generator = nullptr; 610 HcfCipher *cipher = nullptr; 611 HcfSymKey *key = nullptr; 612 ivSpec.iv.data = iv; 613 ivSpec.iv.len = 16; 614 615 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 616 if (ret != 0) { 617 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 618 goto CLEAR_UP; 619 } 620 621 ret = generator->generateSymKey(generator, &key); 622 if (ret != 0) { 623 LOGE("generateSymKey failed!"); 624 } 625 626 ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 627 if (ret != 0) { 628 LOGE("HcfCipherCreate failed!"); 629 goto CLEAR_UP; 630 } 631 632 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 633 if (ret != 0) { 634 LOGE("AesEncrypt failed! %d", ret); 635 goto CLEAR_UP; 636 } 637 638 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 639 if (ret != 0) { 640 LOGE("AesDecrypt failed! %d", ret); 641 goto CLEAR_UP; 642 } 643 644 CLEAR_UP: 645 HcfObjDestroy((HcfObjectBase *)key); 646 HcfObjDestroy((HcfObjectBase *)cipher); 647 HcfObjDestroy((HcfObjectBase *)generator); 648 EXPECT_EQ(ret, 0); 649 } 650 651 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest013, TestSize.Level0) 652 { 653 int ret = 0; 654 uint8_t iv[16] = {0}; 655 uint8_t cipherText[128] = {0}; 656 int cipherTextLen = 128; 657 658 HcfIvParamsSpec ivSpec = {}; 659 HcfSymKeyGenerator *generator = nullptr; 660 HcfCipher *cipher = nullptr; 661 HcfSymKey *key = nullptr; 662 ivSpec.iv.data = iv; 663 ivSpec.iv.len = 16; 664 665 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 666 if (ret != 0) { 667 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 668 goto CLEAR_UP; 669 } 670 671 ret = generator->generateSymKey(generator, &key); 672 if (ret != 0) { 673 LOGE("generateSymKey failed!"); 674 goto CLEAR_UP; 675 } 676 677 ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); 678 if (ret != 0) { 679 LOGE("HcfCipherCreate failed!"); 680 goto CLEAR_UP; 681 } 682 683 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 684 if (ret != 0) { 685 LOGE("AesNoUpdateEncrypt failed! %d", ret); 686 goto CLEAR_UP; 687 } 688 689 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 690 if (ret != 0) { 691 LOGE("AesNoUpdateDecrypt failed! %d", ret); 692 goto CLEAR_UP; 693 } 694 695 CLEAR_UP: 696 HcfObjDestroy((HcfObjectBase *)key); 697 HcfObjDestroy((HcfObjectBase *)cipher); 698 HcfObjDestroy((HcfObjectBase *)generator); 699 EXPECT_EQ(ret, 0); 700 } 701 702 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest014, TestSize.Level0) 703 { 704 int ret = 0; 705 uint8_t iv[16] = {0}; 706 uint8_t cipherText[128] = {0}; 707 int cipherTextLen = 128; 708 709 HcfIvParamsSpec ivSpec = {}; 710 HcfSymKeyGenerator *generator = nullptr; 711 HcfCipher *cipher = nullptr; 712 HcfSymKey *key = nullptr; 713 ivSpec.iv.data = iv; 714 ivSpec.iv.len = 16; 715 716 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 717 if (ret != 0) { 718 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 719 goto CLEAR_UP; 720 } 721 722 ret = generator->generateSymKey(generator, &key); 723 if (ret != 0) { 724 LOGE("generateSymKey failed!"); 725 goto CLEAR_UP; 726 } 727 728 ret = HcfCipherCreate("AES128|CFB|PKCS5", &cipher); 729 if (ret != 0) { 730 LOGE("HcfCipherCreate failed!"); 731 goto CLEAR_UP; 732 } 733 734 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 735 if (ret != 0) { 736 LOGE("AesNoUpdateEncrypt failed! %d", ret); 737 goto CLEAR_UP; 738 } 739 740 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 741 if (ret != 0) { 742 LOGE("AesNoUpdateDecrypt failed! %d", ret); 743 goto CLEAR_UP; 744 } 745 746 CLEAR_UP: 747 HcfObjDestroy((HcfObjectBase *)key); 748 HcfObjDestroy((HcfObjectBase *)cipher); 749 HcfObjDestroy((HcfObjectBase *)generator); 750 EXPECT_EQ(ret, 0); 751 } 752 753 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest015, TestSize.Level0) 754 { 755 int ret = 0; 756 uint8_t iv[16] = {0}; 757 uint8_t cipherText[128] = {0}; 758 int cipherTextLen = 128; 759 760 HcfIvParamsSpec ivSpec = {}; 761 HcfSymKeyGenerator *generator = nullptr; 762 HcfCipher *cipher = nullptr; 763 HcfSymKey *key = nullptr; 764 ivSpec.iv.data = iv; 765 ivSpec.iv.len = 16; 766 767 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 768 if (ret != 0) { 769 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 770 goto CLEAR_UP; 771 } 772 773 ret = generator->generateSymKey(generator, &key); 774 if (ret != 0) { 775 LOGE("generateSymKey failed!"); 776 goto CLEAR_UP; 777 } 778 779 ret = HcfCipherCreate("AES128|CFB|PKCS7", &cipher); 780 if (ret != 0) { 781 LOGE("HcfCipherCreate failed!"); 782 goto CLEAR_UP; 783 } 784 785 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 786 if (ret != 0) { 787 LOGE("AesNoUpdateEncrypt failed! %d", ret); 788 goto CLEAR_UP; 789 } 790 791 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 792 if (ret != 0) { 793 LOGE("AesNoUpdateDecrypt failed! %d", ret); 794 goto CLEAR_UP; 795 } 796 797 CLEAR_UP: 798 HcfObjDestroy((HcfObjectBase *)key); 799 HcfObjDestroy((HcfObjectBase *)cipher); 800 HcfObjDestroy((HcfObjectBase *)generator); 801 EXPECT_EQ(ret, 0); 802 } 803 804 805 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest016, TestSize.Level0) 806 { 807 int ret = 0; 808 uint8_t iv[16] = {0}; 809 uint8_t cipherText[128] = {0}; 810 int cipherTextLen = 128; 811 812 HcfIvParamsSpec ivSpec = {}; 813 HcfSymKeyGenerator *generator = nullptr; 814 HcfCipher *cipher = nullptr; 815 HcfSymKey *key = nullptr; 816 ivSpec.iv.data = iv; 817 ivSpec.iv.len = 16; 818 819 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 820 if (ret != 0) { 821 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 822 goto CLEAR_UP; 823 } 824 825 ret = generator->generateSymKey(generator, &key); 826 if (ret != 0) { 827 LOGE("generateSymKey failed!"); 828 goto CLEAR_UP; 829 } 830 831 ret = HcfCipherCreate("AES128|CFB1|NoPadding", &cipher); 832 if (ret != 0) { 833 LOGE("HcfCipherCreate failed!"); 834 goto CLEAR_UP; 835 } 836 837 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 838 if (ret != 0) { 839 LOGE("AesNoUpdateEncrypt failed! %d", ret); 840 goto CLEAR_UP; 841 } 842 843 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 844 if (ret != 0) { 845 LOGE("AesNoUpdateDecrypt failed! %d", ret); 846 goto CLEAR_UP; 847 } 848 849 CLEAR_UP: 850 HcfObjDestroy((HcfObjectBase *)key); 851 HcfObjDestroy((HcfObjectBase *)cipher); 852 HcfObjDestroy((HcfObjectBase *)generator); 853 EXPECT_EQ(ret, 0); 854 } 855 856 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest017, TestSize.Level0) 857 { 858 int ret = 0; 859 uint8_t iv[16] = {0}; 860 uint8_t cipherText[128] = {0}; 861 int cipherTextLen = 128; 862 863 HcfIvParamsSpec ivSpec = {}; 864 HcfSymKeyGenerator *generator = nullptr; 865 HcfCipher *cipher = nullptr; 866 HcfSymKey *key = nullptr; 867 ivSpec.iv.data = iv; 868 ivSpec.iv.len = 16; 869 870 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 871 if (ret != 0) { 872 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 873 goto CLEAR_UP; 874 } 875 876 ret = generator->generateSymKey(generator, &key); 877 if (ret != 0) { 878 LOGE("generateSymKey failed!"); 879 goto CLEAR_UP; 880 } 881 882 ret = HcfCipherCreate("AES128|CFB1|PKCS5", &cipher); 883 if (ret != 0) { 884 LOGE("HcfCipherCreate failed!"); 885 goto CLEAR_UP; 886 } 887 888 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 889 if (ret != 0) { 890 LOGE("AesNoUpdateEncrypt failed! %d", ret); 891 goto CLEAR_UP; 892 } 893 894 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 895 if (ret != 0) { 896 LOGE("AesNoUpdateDecrypt failed! %d", ret); 897 goto CLEAR_UP; 898 } 899 900 CLEAR_UP: 901 HcfObjDestroy((HcfObjectBase *)key); 902 HcfObjDestroy((HcfObjectBase *)cipher); 903 HcfObjDestroy((HcfObjectBase *)generator); 904 EXPECT_EQ(ret, 0); 905 } 906 907 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest018, TestSize.Level0) 908 { 909 int ret = 0; 910 uint8_t iv[16] = {0}; 911 uint8_t cipherText[128] = {0}; 912 int cipherTextLen = 128; 913 914 HcfIvParamsSpec ivSpec = {}; 915 HcfSymKeyGenerator *generator = nullptr; 916 HcfCipher *cipher = nullptr; 917 HcfSymKey *key = nullptr; 918 ivSpec.iv.data = iv; 919 ivSpec.iv.len = 16; 920 921 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 922 if (ret != 0) { 923 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 924 goto CLEAR_UP; 925 } 926 927 ret = generator->generateSymKey(generator, &key); 928 if (ret != 0) { 929 LOGE("generateSymKey failed!"); 930 } 931 932 ret = HcfCipherCreate("AES128|CFB1|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 933 if (ret != 0) { 934 LOGE("HcfCipherCreate failed!"); 935 goto CLEAR_UP; 936 } 937 938 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 939 if (ret != 0) { 940 LOGE("AesNoUpdateEncrypt failed! %d", ret); 941 goto CLEAR_UP; 942 } 943 944 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 945 if (ret != 0) { 946 LOGE("AesNoUpdateDecrypt failed! %d", ret); 947 goto CLEAR_UP; 948 } 949 950 CLEAR_UP: 951 HcfObjDestroy((HcfObjectBase *)key); 952 HcfObjDestroy((HcfObjectBase *)cipher); 953 HcfObjDestroy((HcfObjectBase *)generator); 954 EXPECT_EQ(ret, 0); 955 } 956 957 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest019, TestSize.Level0) 958 { 959 int ret = 0; 960 uint8_t iv[16] = {0}; 961 uint8_t cipherText[128] = {0}; 962 int cipherTextLen = 128; 963 964 HcfIvParamsSpec ivSpec = {}; 965 HcfSymKeyGenerator *generator = nullptr; 966 HcfCipher *cipher = nullptr; 967 HcfSymKey *key = nullptr; 968 ivSpec.iv.data = iv; 969 ivSpec.iv.len = 16; 970 971 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 972 if (ret != 0) { 973 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 974 goto CLEAR_UP; 975 } 976 977 ret = generator->generateSymKey(generator, &key); 978 if (ret != 0) { 979 LOGE("generateSymKey failed!"); 980 } 981 982 ret = HcfCipherCreate("AES128|CFB8|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit 983 if (ret != 0) { 984 LOGE("HcfCipherCreate failed!"); 985 goto CLEAR_UP; 986 } 987 988 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 989 if (ret != 0) { 990 LOGE("AesNoUpdateEncrypt failed! %d", ret); 991 goto CLEAR_UP; 992 } 993 994 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 995 if (ret != 0) { 996 LOGE("AesNoUpdateDecrypt failed! %d", ret); 997 goto CLEAR_UP; 998 } 999 1000 CLEAR_UP: 1001 HcfObjDestroy((HcfObjectBase *)key); 1002 HcfObjDestroy((HcfObjectBase *)cipher); 1003 HcfObjDestroy((HcfObjectBase *)generator); 1004 EXPECT_EQ(ret, 0); 1005 } 1006 1007 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest020, TestSize.Level0) 1008 { 1009 int ret = 0; 1010 uint8_t iv[16] = {0}; 1011 uint8_t cipherText[128] = {0}; 1012 int cipherTextLen = 128; 1013 1014 HcfIvParamsSpec ivSpec = {}; 1015 HcfSymKeyGenerator *generator = nullptr; 1016 HcfCipher *cipher = nullptr; 1017 HcfSymKey *key = nullptr; 1018 ivSpec.iv.data = iv; 1019 ivSpec.iv.len = 16; 1020 1021 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1022 if (ret != 0) { 1023 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1024 goto CLEAR_UP; 1025 } 1026 1027 ret = generator->generateSymKey(generator, &key); 1028 if (ret != 0) { 1029 LOGE("generateSymKey failed!"); 1030 } 1031 1032 ret = HcfCipherCreate("AES128|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1033 if (ret != 0) { 1034 LOGE("HcfCipherCreate failed!"); 1035 goto CLEAR_UP; 1036 } 1037 1038 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 1039 if (ret != 0) { 1040 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1041 goto CLEAR_UP; 1042 } 1043 1044 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 1045 if (ret != 0) { 1046 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1047 goto CLEAR_UP; 1048 } 1049 1050 CLEAR_UP: 1051 HcfObjDestroy((HcfObjectBase *)key); 1052 HcfObjDestroy((HcfObjectBase *)cipher); 1053 HcfObjDestroy((HcfObjectBase *)generator); 1054 EXPECT_EQ(ret, 0); 1055 } 1056 1057 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest021, TestSize.Level0) 1058 { 1059 int ret = 0; 1060 uint8_t iv[16] = {0}; 1061 uint8_t cipherText[128] = {0}; 1062 int cipherTextLen = 128; 1063 1064 HcfIvParamsSpec ivSpec = {}; 1065 HcfSymKeyGenerator *generator = nullptr; 1066 HcfCipher *cipher = nullptr; 1067 HcfSymKey *key = nullptr; 1068 ivSpec.iv.data = iv; 1069 ivSpec.iv.len = 16; 1070 1071 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1072 if (ret != 0) { 1073 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1074 goto CLEAR_UP; 1075 } 1076 1077 ret = generator->generateSymKey(generator, &key); 1078 if (ret != 0) { 1079 LOGE("generateSymKey failed!"); 1080 } 1081 1082 ret = HcfCipherCreate("AES128|CFB8|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 1083 if (ret != 0) { 1084 LOGE("HcfCipherCreate failed!"); 1085 goto CLEAR_UP; 1086 } 1087 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 1088 if (ret != 0) { 1089 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1090 goto CLEAR_UP; 1091 } 1092 1093 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 1094 if (ret != 0) { 1095 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1096 goto CLEAR_UP; 1097 } 1098 1099 CLEAR_UP: 1100 HcfObjDestroy((HcfObjectBase *)key); 1101 HcfObjDestroy((HcfObjectBase *)cipher); 1102 HcfObjDestroy((HcfObjectBase *)generator); 1103 EXPECT_EQ(ret, 0); 1104 } 1105 1106 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest022, TestSize.Level0) 1107 { 1108 int ret = 0; 1109 uint8_t iv[16] = {0}; 1110 uint8_t cipherText[128] = {0}; 1111 int cipherTextLen = 128; 1112 1113 HcfIvParamsSpec ivSpec = {}; 1114 HcfSymKeyGenerator *generator = nullptr; 1115 HcfCipher *cipher = nullptr; 1116 HcfSymKey *key = nullptr; 1117 ivSpec.iv.data = iv; 1118 ivSpec.iv.len = 16; 1119 1120 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1121 if (ret != 0) { 1122 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1123 goto CLEAR_UP; 1124 } 1125 1126 ret = generator->generateSymKey(generator, &key); 1127 if (ret != 0) { 1128 LOGE("generateSymKey failed!"); 1129 } 1130 1131 ret = HcfCipherCreate("AES128|CFB128|NoPadding", &cipher); // CFB1/CFB8/CFB128 bit 1132 if (ret != 0) { 1133 LOGE("HcfCipherCreate failed!"); 1134 goto CLEAR_UP; 1135 } 1136 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 1137 if (ret != 0) { 1138 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1139 goto CLEAR_UP; 1140 } 1141 1142 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 1143 if (ret != 0) { 1144 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1145 goto CLEAR_UP; 1146 } 1147 1148 CLEAR_UP: 1149 HcfObjDestroy((HcfObjectBase *)key); 1150 HcfObjDestroy((HcfObjectBase *)cipher); 1151 HcfObjDestroy((HcfObjectBase *)generator); 1152 EXPECT_EQ(ret, 0); 1153 } 1154 1155 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest023, TestSize.Level0) 1156 { 1157 int ret = 0; 1158 uint8_t iv[16] = {0}; 1159 uint8_t cipherText[128] = {0}; 1160 int cipherTextLen = 128; 1161 1162 HcfIvParamsSpec ivSpec = {}; 1163 HcfSymKeyGenerator *generator = nullptr; 1164 HcfCipher *cipher = nullptr; 1165 HcfSymKey *key = nullptr; 1166 ivSpec.iv.data = iv; 1167 ivSpec.iv.len = 16; 1168 1169 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1170 if (ret != 0) { 1171 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1172 goto CLEAR_UP; 1173 } 1174 1175 ret = generator->generateSymKey(generator, &key); 1176 if (ret != 0) { 1177 LOGE("generateSymKey failed!"); 1178 } 1179 1180 ret = HcfCipherCreate("AES128|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1181 if (ret != 0) { 1182 LOGE("HcfCipherCreate failed!"); 1183 goto CLEAR_UP; 1184 } 1185 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 1186 if (ret != 0) { 1187 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1188 goto CLEAR_UP; 1189 } 1190 1191 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 1192 if (ret != 0) { 1193 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1194 goto CLEAR_UP; 1195 } 1196 1197 CLEAR_UP: 1198 HcfObjDestroy((HcfObjectBase *)key); 1199 HcfObjDestroy((HcfObjectBase *)cipher); 1200 HcfObjDestroy((HcfObjectBase *)generator); 1201 EXPECT_EQ(ret, 0); 1202 } 1203 1204 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest024, TestSize.Level0) 1205 { 1206 int ret = 0; 1207 uint8_t iv[16] = {0}; 1208 uint8_t cipherText[128] = {0}; 1209 int cipherTextLen = 128; 1210 1211 HcfIvParamsSpec ivSpec = {}; 1212 HcfSymKeyGenerator *generator = nullptr; 1213 HcfCipher *cipher = nullptr; 1214 HcfSymKey *key = nullptr; 1215 ivSpec.iv.data = iv; 1216 ivSpec.iv.len = 16; 1217 1218 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1219 if (ret != 0) { 1220 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1221 goto CLEAR_UP; 1222 } 1223 1224 ret = generator->generateSymKey(generator, &key); 1225 if (ret != 0) { 1226 LOGE("generateSymKey failed!"); 1227 } 1228 1229 ret = HcfCipherCreate("AES128|CFB128|PKCS7", &cipher); // CFB1/CFB8/CFB128 bit 1230 if (ret != 0) { 1231 LOGE("HcfCipherCreate failed!"); 1232 goto CLEAR_UP; 1233 } 1234 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 1235 if (ret != 0) { 1236 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1237 goto CLEAR_UP; 1238 } 1239 1240 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 1241 if (ret != 0) { 1242 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1243 goto CLEAR_UP; 1244 } 1245 1246 CLEAR_UP: 1247 HcfObjDestroy((HcfObjectBase *)key); 1248 HcfObjDestroy((HcfObjectBase *)cipher); 1249 HcfObjDestroy((HcfObjectBase *)generator); 1250 EXPECT_EQ(ret, 0); 1251 } 1252 1253 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest025, TestSize.Level0) 1254 { 1255 int ret = 0; 1256 uint8_t iv[16] = {0}; 1257 1258 HcfIvParamsSpec ivSpec = {}; 1259 HcfCipher *cipher = nullptr; 1260 HcfSymKey *key = nullptr; 1261 ivSpec.iv.data = iv; 1262 ivSpec.iv.len = 16; 1263 1264 ret = GenerateSymKey("AES128", &key); 1265 if (ret != 0) { 1266 LOGE("GenerateSymKey failed!"); 1267 goto CLEAR_UP; 1268 } 1269 1270 ret = HcfCipherCreate("AES128|CFB|NoPadding", &cipher); 1271 if (ret != 0) { 1272 LOGE("HcfCipherCreate failed!"); 1273 goto CLEAR_UP; 1274 } 1275 ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); 1276 if (ret != 0) { 1277 LOGE("GeneratorFile failed!"); 1278 goto CLEAR_UP; 1279 } 1280 1281 ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 1282 if (ret != 0) { 1283 LOGE("AesNoUpdateEncrypt failed! %d", ret); 1284 goto CLEAR_UP; 1285 } 1286 1287 ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 1288 if (ret != 0) { 1289 LOGE("AesNoUpdateDecrypt failed! %d", ret); 1290 goto CLEAR_UP; 1291 } 1292 ret = CompareFileContent(); 1293 if (ret != 0) { 1294 LOGE("CompareFileContent failed!"); 1295 goto CLEAR_UP; 1296 } 1297 1298 CLEAR_UP: 1299 HcfObjDestroy((HcfObjectBase *)key); 1300 HcfObjDestroy((HcfObjectBase *)cipher); 1301 EXPECT_EQ(ret, 0); 1302 } 1303 1304 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest026, TestSize.Level0) 1305 { 1306 int ret = 0; 1307 uint8_t iv[AES_IV_LEN] = { 0 }; 1308 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1309 int cipherTextLen = CIPHER_TEXT_LEN; 1310 1311 HcfIvParamsSpec ivSpec = {}; 1312 HcfCipher *cipher = nullptr; 1313 HcfSymKey *key = nullptr; 1314 ivSpec.iv.data = iv; 1315 ivSpec.iv.len = AES_IV_LEN; 1316 1317 ret = GenerateSymKey("AES192", &key); 1318 if (ret != 0) { 1319 LOGE("GenerateSymKey failed!"); 1320 goto CLEAR_UP; 1321 } 1322 1323 ret = HcfCipherCreate("AES192|CFB|PKCS5", &cipher); 1324 if (ret != 0) { 1325 LOGE("HcfCipherCreate failed!"); 1326 goto CLEAR_UP; 1327 } 1328 1329 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1330 if (ret != 0) { 1331 LOGE("AesEncrypt failed! %d", ret); 1332 goto CLEAR_UP; 1333 } 1334 1335 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1336 if (ret != 0) { 1337 LOGE("AesDecrypt failed! %d", ret); 1338 } 1339 1340 CLEAR_UP: 1341 HcfObjDestroy(key); 1342 HcfObjDestroy(cipher); 1343 EXPECT_EQ(ret, 0); 1344 } 1345 1346 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest027, TestSize.Level0) 1347 { 1348 int ret = 0; 1349 uint8_t iv[AES_IV_LEN] = { 0 }; 1350 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1351 int cipherTextLen = CIPHER_TEXT_LEN; 1352 1353 HcfIvParamsSpec ivSpec = {}; 1354 HcfCipher *cipher = nullptr; 1355 HcfSymKey *key = nullptr; 1356 ivSpec.iv.data = iv; 1357 ivSpec.iv.len = AES_IV_LEN; 1358 1359 ret = GenerateSymKey("AES256", &key); 1360 if (ret != 0) { 1361 LOGE("GenerateSymKey failed!"); 1362 goto CLEAR_UP; 1363 } 1364 1365 ret = HcfCipherCreate("AES256|CFB|PKCS5", &cipher); 1366 if (ret != 0) { 1367 LOGE("HcfCipherCreate failed!"); 1368 goto CLEAR_UP; 1369 } 1370 1371 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1372 if (ret != 0) { 1373 LOGE("AesEncrypt failed! %d", ret); 1374 goto CLEAR_UP; 1375 } 1376 1377 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1378 if (ret != 0) { 1379 LOGE("AesDecrypt failed! %d", ret); 1380 } 1381 1382 CLEAR_UP: 1383 HcfObjDestroy(key); 1384 HcfObjDestroy(cipher); 1385 EXPECT_EQ(ret, 0); 1386 } 1387 1388 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest028, TestSize.Level0) 1389 { 1390 int ret = 0; 1391 uint8_t iv[AES_IV_LEN] = { 0 }; 1392 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1393 int cipherTextLen = CIPHER_TEXT_LEN; 1394 1395 HcfIvParamsSpec ivSpec = {}; 1396 HcfCipher *cipher = nullptr; 1397 HcfSymKey *key = nullptr; 1398 ivSpec.iv.data = iv; 1399 ivSpec.iv.len = AES_IV_LEN; 1400 1401 ret = GenerateSymKey("AES192", &key); 1402 if (ret != 0) { 1403 LOGE("GenerateSymKey failed!"); 1404 goto CLEAR_UP; 1405 } 1406 1407 ret = HcfCipherCreate("AES192|CFB1|PKCS5", &cipher); 1408 if (ret != 0) { 1409 LOGE("HcfCipherCreate failed!"); 1410 goto CLEAR_UP; 1411 } 1412 1413 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1414 if (ret != 0) { 1415 LOGE("AesEncrypt failed! %d", ret); 1416 goto CLEAR_UP; 1417 } 1418 1419 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1420 if (ret != 0) { 1421 LOGE("AesDecrypt failed! %d", ret); 1422 } 1423 1424 CLEAR_UP: 1425 HcfObjDestroy(key); 1426 HcfObjDestroy(cipher); 1427 EXPECT_EQ(ret, 0); 1428 } 1429 1430 1431 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest029, TestSize.Level0) 1432 { 1433 int ret = 0; 1434 uint8_t iv[AES_IV_LEN] = { 0 }; 1435 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1436 int cipherTextLen = CIPHER_TEXT_LEN; 1437 1438 HcfIvParamsSpec ivSpec = {}; 1439 HcfCipher *cipher = nullptr; 1440 HcfSymKey *key = nullptr; 1441 ivSpec.iv.data = iv; 1442 ivSpec.iv.len = AES_IV_LEN; 1443 1444 ret = GenerateSymKey("AES256", &key); 1445 if (ret != 0) { 1446 LOGE("GenerateSymKey failed!"); 1447 goto CLEAR_UP; 1448 } 1449 1450 ret = HcfCipherCreate("AES256|CFB1|PKCS5", &cipher); 1451 if (ret != 0) { 1452 LOGE("HcfCipherCreate failed!"); 1453 goto CLEAR_UP; 1454 } 1455 1456 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1457 if (ret != 0) { 1458 LOGE("AesEncrypt failed! %d", ret); 1459 goto CLEAR_UP; 1460 } 1461 1462 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1463 if (ret != 0) { 1464 LOGE("AesDecrypt failed! %d", ret); 1465 } 1466 1467 CLEAR_UP: 1468 HcfObjDestroy(key); 1469 HcfObjDestroy(cipher); 1470 EXPECT_EQ(ret, 0); 1471 } 1472 1473 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest030, TestSize.Level0) 1474 { 1475 int ret = 0; 1476 uint8_t iv[AES_IV_LEN] = { 0 }; 1477 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1478 int cipherTextLen = CIPHER_TEXT_LEN; 1479 1480 HcfIvParamsSpec ivSpec = {}; 1481 HcfCipher *cipher = nullptr; 1482 HcfSymKey *key = nullptr; 1483 ivSpec.iv.data = iv; 1484 ivSpec.iv.len = AES_IV_LEN; 1485 1486 ret = GenerateSymKey("AES192", &key); 1487 if (ret != 0) { 1488 LOGE("GenerateSymKey failed!"); 1489 goto CLEAR_UP; 1490 } 1491 1492 ret = HcfCipherCreate("AES192|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1493 if (ret != 0) { 1494 LOGE("HcfCipherCreate failed!"); 1495 goto CLEAR_UP; 1496 } 1497 1498 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1499 if (ret != 0) { 1500 LOGE("AesEncrypt failed! %d", ret); 1501 goto CLEAR_UP; 1502 } 1503 1504 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1505 if (ret != 0) { 1506 LOGE("AesDecrypt failed! %d", ret); 1507 } 1508 1509 CLEAR_UP: 1510 HcfObjDestroy(key); 1511 HcfObjDestroy(cipher); 1512 EXPECT_EQ(ret, 0); 1513 } 1514 1515 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest031, TestSize.Level0) 1516 { 1517 int ret = 0; 1518 uint8_t iv[AES_IV_LEN] = { 0 }; 1519 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1520 int cipherTextLen = CIPHER_TEXT_LEN; 1521 1522 HcfIvParamsSpec ivSpec = {}; 1523 HcfCipher *cipher = nullptr; 1524 HcfSymKey *key = nullptr; 1525 ivSpec.iv.data = iv; 1526 ivSpec.iv.len = AES_IV_LEN; 1527 1528 ret = GenerateSymKey("AES256", &key); 1529 if (ret != 0) { 1530 LOGE("GenerateSymKey failed!"); 1531 goto CLEAR_UP; 1532 } 1533 1534 ret = HcfCipherCreate("AES256|CFB8|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1535 if (ret != 0) { 1536 LOGE("HcfCipherCreate failed!"); 1537 goto CLEAR_UP; 1538 } 1539 1540 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1541 if (ret != 0) { 1542 LOGE("AesEncrypt failed! %d", ret); 1543 goto CLEAR_UP; 1544 } 1545 1546 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1547 if (ret != 0) { 1548 LOGE("AesDecrypt failed! %d", ret); 1549 } 1550 1551 CLEAR_UP: 1552 HcfObjDestroy(key); 1553 HcfObjDestroy(cipher); 1554 EXPECT_EQ(ret, 0); 1555 } 1556 1557 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest032, TestSize.Level0) 1558 { 1559 int ret = 0; 1560 uint8_t iv[AES_IV_LEN] = { 0 }; 1561 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1562 int cipherTextLen = CIPHER_TEXT_LEN; 1563 1564 HcfIvParamsSpec ivSpec = {}; 1565 HcfCipher *cipher = nullptr; 1566 HcfSymKey *key = nullptr; 1567 ivSpec.iv.data = iv; 1568 ivSpec.iv.len = AES_IV_LEN; 1569 1570 ret = GenerateSymKey("AES192", &key); 1571 if (ret != 0) { 1572 LOGE("GenerateSymKey failed!"); 1573 goto CLEAR_UP; 1574 } 1575 1576 ret = HcfCipherCreate("AES192|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1577 if (ret != 0) { 1578 LOGE("HcfCipherCreate failed!"); 1579 goto CLEAR_UP; 1580 } 1581 1582 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1583 if (ret != 0) { 1584 LOGE("AesEncrypt failed! %d", ret); 1585 goto CLEAR_UP; 1586 } 1587 1588 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1589 if (ret != 0) { 1590 LOGE("AesDecrypt failed! %d", ret); 1591 } 1592 1593 CLEAR_UP: 1594 HcfObjDestroy(key); 1595 HcfObjDestroy(cipher); 1596 EXPECT_EQ(ret, 0); 1597 } 1598 1599 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest033, TestSize.Level0) 1600 { 1601 int ret = 0; 1602 uint8_t iv[AES_IV_LEN] = { 0 }; 1603 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1604 int cipherTextLen = CIPHER_TEXT_LEN; 1605 1606 HcfIvParamsSpec ivSpec = {}; 1607 HcfCipher *cipher = nullptr; 1608 HcfSymKey *key = nullptr; 1609 ivSpec.iv.data = iv; 1610 ivSpec.iv.len = AES_IV_LEN; 1611 1612 ret = GenerateSymKey("AES256", &key); 1613 if (ret != 0) { 1614 LOGE("GenerateSymKey failed!"); 1615 goto CLEAR_UP; 1616 } 1617 1618 ret = HcfCipherCreate("AES256|CFB128|PKCS5", &cipher); // CFB1/CFB8/CFB128 bit 1619 if (ret != 0) { 1620 LOGE("HcfCipherCreate failed!"); 1621 goto CLEAR_UP; 1622 } 1623 1624 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 1625 if (ret != 0) { 1626 LOGE("AesEncrypt failed! %d", ret); 1627 goto CLEAR_UP; 1628 } 1629 1630 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 1631 if (ret != 0) { 1632 LOGE("AesDecrypt failed! %d", ret); 1633 } 1634 1635 CLEAR_UP: 1636 HcfObjDestroy(key); 1637 HcfObjDestroy(cipher); 1638 EXPECT_EQ(ret, 0); 1639 } 1640 1641 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest034, TestSize.Level0) 1642 { 1643 int ret = 0; 1644 HcfCipher *cipher = nullptr; 1645 const char *cipherName = "AES128|CFB|NoPadding"; 1646 const char *retAlgo = nullptr; 1647 ret = HcfCipherCreate(cipherName, &cipher); 1648 if (ret != 0) { 1649 LOGE("HcfCipherCreate failed!"); 1650 goto CLEAR_UP; 1651 } 1652 1653 retAlgo = cipher->getAlgorithm(cipher); 1654 if (retAlgo == nullptr) { 1655 LOGE("cipher getAlgorithm failed!"); 1656 ret = HCF_ERR_CRYPTO_OPERATION; 1657 goto CLEAR_UP; 1658 } 1659 1660 ret = strcmp(retAlgo, cipherName); 1661 if (ret != 0) { 1662 LOGE("cipher getAlgorithm failed!"); 1663 } 1664 CLEAR_UP: 1665 HcfObjDestroy(cipher); 1666 EXPECT_EQ(ret, 0); 1667 } 1668 1669 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest035, TestSize.Level0) 1670 { 1671 int ret = 0; 1672 HcfCipher *cipher = nullptr; 1673 const char *cipherName = "AES128|CFB|NoPadding"; 1674 const char *retAlgo = nullptr; 1675 ret = HcfCipherCreate(cipherName, &cipher); 1676 if (ret != 0) { 1677 LOGE("HcfCipherCreate failed!"); 1678 goto CLEAR_UP; 1679 } 1680 1681 retAlgo = cipher->getAlgorithm(nullptr); 1682 if (retAlgo == nullptr) { 1683 LOGE("cipher getAlgorithm failed!"); 1684 ret = HCF_ERR_CRYPTO_OPERATION; 1685 } 1686 1687 CLEAR_UP: 1688 HcfObjDestroy(cipher); 1689 EXPECT_NE(ret, 0); 1690 } 1691 1692 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest036, TestSize.Level0) 1693 { 1694 int ret = 0; 1695 HcfCipher *cipher = nullptr; 1696 HcfSymKeyGenerator *generator = nullptr; 1697 const char *cipherName = "AES128|CFB|NoPadding"; 1698 const char *retAlgo = nullptr; 1699 1700 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 1701 if (ret != 0) { 1702 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 1703 goto CLEAR_UP; 1704 } 1705 1706 ret = HcfCipherCreate(cipherName, &cipher); 1707 if (ret != 0) { 1708 LOGE("HcfCipherCreate failed!"); 1709 goto CLEAR_UP; 1710 } 1711 1712 retAlgo = cipher->getAlgorithm(reinterpret_cast<HcfCipher *>(generator)); 1713 if (retAlgo == nullptr) { 1714 LOGE("cipher getAlgorithm failed!"); 1715 ret = HCF_ERR_CRYPTO_OPERATION; 1716 } 1717 1718 CLEAR_UP: 1719 HcfObjDestroy(generator); 1720 HcfObjDestroy(cipher); 1721 EXPECT_NE(ret, 0); 1722 } 1723 1724 HWTEST_F(CryptoAesCfbCipherTest, CryptoAesCfbCipherTest037, TestSize.Level0) 1725 { 1726 int ret = 0; 1727 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1728 int cipherTextLen = CIPHER_TEXT_LEN; 1729 HcfSymKey *key = nullptr; 1730 HcfCipher *cipher = nullptr; 1731 1732 ret = GenerateSymKey("AES256", &key); 1733 if (ret != 0) { 1734 LOGE("GenerateSymKey failed!"); 1735 goto CLEAR_UP; 1736 } 1737 1738 ret = HcfCipherCreate("AES256|CFB128|PKCS5", &cipher); 1739 if (ret != 0) { 1740 LOGE("HcfCipherCreate failed!"); 1741 goto CLEAR_UP; 1742 } 1743 1744 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 1745 if (ret != 0) { 1746 LOGE("AesEncrypt failed! %d", ret); 1747 goto CLEAR_UP; 1748 } 1749 1750 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 1751 if (ret != 0) { 1752 LOGE("AesDecrypt failed! %d", ret); 1753 } 1754 1755 CLEAR_UP: 1756 HcfObjDestroy(key); 1757 HcfObjDestroy(cipher); 1758 EXPECT_NE(ret, 0); 1759 } 1760 }