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 CryptoAesEcbCipherTest : 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 /** 46 * @tc.name: CryptoAesEcbCipherTest.CryptoAesEcbCipherTest001 47 * @tc.desc: Verify whether the crypto framework is normal. 48 * @tc.type: FUNC 49 * @tc.require: I5QWEO 50 */ 51 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest001, TestSize.Level0) 52 { 53 int ret = 0; 54 uint8_t cipherText[128] = {0}; 55 int cipherTextLen = 128; 56 57 HcfSymKeyGenerator *generator = nullptr; 58 HcfCipher *cipher = nullptr; 59 HcfSymKey *key = nullptr; 60 61 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 62 if (ret != 0) { 63 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 64 goto CLEAR_UP; 65 } 66 67 ret = generator->generateSymKey(generator, &key); 68 if (ret != 0) { 69 LOGE("generateSymKey failed!"); 70 goto CLEAR_UP; 71 } 72 73 ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); 74 if (ret != 0) { 75 LOGE("HcfCipherCreate failed!"); 76 goto CLEAR_UP; 77 } 78 79 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 80 if (ret != 0) { 81 LOGE("AesEncrypt failed! %d", ret); 82 goto CLEAR_UP; 83 } 84 85 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 86 if (ret != 0) { 87 LOGE("AesDecrypt failed! %d", ret); 88 goto CLEAR_UP; 89 } 90 CLEAR_UP: 91 HcfObjDestroy((HcfObjectBase *)key); 92 HcfObjDestroy((HcfObjectBase *)cipher); 93 HcfObjDestroy((HcfObjectBase *)generator); 94 EXPECT_NE(ret, 0); 95 } 96 97 /** 98 * @tc.name: CryptoAesEcbCipherTest.CryptoAesEcbCipherTest002 99 * @tc.desc: Verify AES128 cipher algorithm. 100 * @tc.type: FUNC 101 * @tc.require: I5QWEG 102 */ 103 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest002, TestSize.Level0) 104 { 105 int ret = 0; 106 uint8_t cipherText[128] = {0}; 107 int cipherTextLen = 128; 108 109 HcfSymKeyGenerator *generator = nullptr; 110 HcfCipher *cipher = nullptr; 111 HcfSymKey *key = nullptr; 112 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 113 if (ret != 0) { 114 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 115 goto CLEAR_UP; 116 } 117 118 ret = generator->generateSymKey(generator, &key); 119 if (ret != 0) { 120 LOGE("generateSymKey failed!"); 121 goto CLEAR_UP; 122 } 123 124 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 125 if (ret != 0) { 126 LOGE("HcfCipherCreate failed!"); 127 goto CLEAR_UP; 128 } 129 130 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 131 if (ret != 0) { 132 LOGE("AesEncrypt failed! %d", ret); 133 goto CLEAR_UP; 134 } 135 136 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 137 if (ret != 0) { 138 LOGE("AesDecrypt failed! %d", ret); 139 goto CLEAR_UP; 140 } 141 CLEAR_UP: 142 HcfObjDestroy((HcfObjectBase *)key); 143 HcfObjDestroy((HcfObjectBase *)cipher); 144 HcfObjDestroy((HcfObjectBase *)generator); 145 EXPECT_EQ(ret, 0); 146 } 147 148 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest003, TestSize.Level0) 149 { 150 int ret = 0; 151 uint8_t cipherText[128] = {0}; 152 int cipherTextLen = 128; 153 154 HcfSymKeyGenerator *generator = nullptr; 155 HcfCipher *cipher = nullptr; 156 HcfSymKey *key = nullptr; 157 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 158 if (ret != 0) { 159 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 160 goto CLEAR_UP; 161 } 162 163 ret = generator->generateSymKey(generator, &key); 164 if (ret != 0) { 165 LOGE("generateSymKey failed!"); 166 goto CLEAR_UP; 167 } 168 169 ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); 170 if (ret != 0) { 171 LOGE("HcfCipherCreate failed!"); 172 goto CLEAR_UP; 173 } 174 175 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 176 if (ret != 0) { 177 LOGE("AesEncrypt failed! %d", ret); 178 goto CLEAR_UP; 179 } 180 181 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 182 if (ret != 0) { 183 LOGE("AesDecrypt failed! %d", ret); 184 goto CLEAR_UP; 185 } 186 187 CLEAR_UP: 188 HcfObjDestroy((HcfObjectBase *)key); 189 HcfObjDestroy((HcfObjectBase *)cipher); 190 HcfObjDestroy((HcfObjectBase *)generator); 191 EXPECT_EQ(ret, 0); 192 } 193 194 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest004, TestSize.Level0) 195 { 196 int ret = 0; 197 uint8_t cipherText[128] = {0}; 198 int cipherTextLen = 128; 199 200 HcfCipher *cipher = nullptr; 201 HcfSymKey *key = nullptr; 202 uint8_t codeCipherText[] = { 203 0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32, 204 0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE 205 }; 206 207 ret = ConvertSymKey("AES128", &key); 208 if (ret != 0) { 209 LOGE("generateSymKey failed!"); 210 goto CLEAR_UP; 211 } 212 213 ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); 214 if (ret != 0) { 215 LOGE("HcfCipherCreate failed!"); 216 goto CLEAR_UP; 217 } 218 219 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 220 if (ret != 0) { 221 LOGE("AesEncrypt failed! %d", ret); 222 goto CLEAR_UP; 223 } 224 225 ret = memcmp(cipherText, codeCipherText, cipherTextLen); 226 if (ret != 0) { 227 LOGE("cipherText compare failed!"); 228 goto CLEAR_UP; 229 } 230 231 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 232 if (ret != 0) { 233 LOGE("AesDecrypt failed! %d", ret); 234 goto CLEAR_UP; 235 } 236 237 CLEAR_UP: 238 HcfObjDestroy((HcfObjectBase *)key); 239 HcfObjDestroy((HcfObjectBase *)cipher); 240 EXPECT_EQ(ret, 0); 241 } 242 243 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest005, TestSize.Level0) 244 { 245 int ret = 0; 246 uint8_t cipherText[128] = {0}; 247 int cipherTextLen = 128; 248 249 HcfSymKeyGenerator *generator = nullptr; 250 HcfCipher *cipher = nullptr; 251 HcfSymKey *key = nullptr; 252 253 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 254 if (ret != 0) { 255 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 256 goto CLEAR_UP; 257 } 258 259 ret = generator->generateSymKey(generator, &key); 260 if (ret != 0) { 261 LOGE("generateSymKey failed!"); 262 goto CLEAR_UP; 263 } 264 265 ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); 266 if (ret != 0) { 267 LOGE("HcfCipherCreate failed!"); 268 goto CLEAR_UP; 269 } 270 271 ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 272 if (ret != 0) { 273 LOGE("AesNoUpdateEncrypt failed! %d", ret); 274 goto CLEAR_UP; 275 } 276 277 ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 278 if (ret != 0) { 279 LOGE("AesNoUpdateDecrypt failed! %d", ret); 280 goto CLEAR_UP; 281 } 282 CLEAR_UP: 283 HcfObjDestroy((HcfObjectBase *)key); 284 HcfObjDestroy((HcfObjectBase *)cipher); 285 HcfObjDestroy((HcfObjectBase *)generator); 286 EXPECT_NE(ret, 0); 287 } 288 289 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest006, TestSize.Level0) 290 { 291 int ret = 0; 292 uint8_t cipherText[128] = {0}; 293 int cipherTextLen = 128; 294 295 HcfSymKeyGenerator *generator = nullptr; 296 HcfCipher *cipher = nullptr; 297 HcfSymKey *key = nullptr; 298 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 299 if (ret != 0) { 300 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 301 goto CLEAR_UP; 302 } 303 304 ret = generator->generateSymKey(generator, &key); 305 if (ret != 0) { 306 LOGE("generateSymKey failed!"); 307 goto CLEAR_UP; 308 } 309 310 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 311 if (ret != 0) { 312 LOGE("HcfCipherCreate failed!"); 313 goto CLEAR_UP; 314 } 315 316 ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 317 if (ret != 0) { 318 LOGE("AesNoUpdateEncrypt failed! %d", ret); 319 goto CLEAR_UP; 320 } 321 322 ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 323 if (ret != 0) { 324 LOGE("AesNoUpdateDecrypt failed! %d", ret); 325 goto CLEAR_UP; 326 } 327 CLEAR_UP: 328 HcfObjDestroy((HcfObjectBase *)key); 329 HcfObjDestroy((HcfObjectBase *)cipher); 330 HcfObjDestroy((HcfObjectBase *)generator); 331 EXPECT_EQ(ret, 0); 332 } 333 334 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest007, 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 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 344 if (ret != 0) { 345 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 346 goto CLEAR_UP; 347 } 348 349 ret = generator->generateSymKey(generator, &key); 350 if (ret != 0) { 351 LOGE("generateSymKey failed!"); 352 goto CLEAR_UP; 353 } 354 355 ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); 356 if (ret != 0) { 357 LOGE("HcfCipherCreate failed!"); 358 goto CLEAR_UP; 359 } 360 361 ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 362 if (ret != 0) { 363 LOGE("AesNoUpdateEncrypt failed! %d", ret); 364 goto CLEAR_UP; 365 } 366 367 ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 368 if (ret != 0) { 369 LOGE("AesNoUpdateDecrypt failed! %d", ret); 370 goto CLEAR_UP; 371 } 372 373 CLEAR_UP: 374 HcfObjDestroy((HcfObjectBase *)key); 375 HcfObjDestroy((HcfObjectBase *)cipher); 376 HcfObjDestroy((HcfObjectBase *)generator); 377 EXPECT_EQ(ret, 0); 378 } 379 380 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest008, TestSize.Level0) 381 { 382 int ret = 0; 383 uint8_t cipherText[128] = {0}; 384 int cipherTextLen = 128; 385 386 HcfCipher *cipher = nullptr; 387 HcfSymKey *key = nullptr; 388 uint8_t codeCipherText[] = { 389 0xF5, 0x12, 0xA0, 0x33, 0xCD, 0xCF, 0x0D, 0x32, 390 0x3E, 0xFF, 0x80, 0x53, 0x89, 0xB6, 0xE4, 0xFE 391 }; 392 393 ret = ConvertSymKey("AES128", &key); 394 if (ret != 0) { 395 LOGE("ConvertSymKey failed!"); 396 goto CLEAR_UP; 397 } 398 399 ret = HcfCipherCreate("AES128|ECB|PKCS7", &cipher); 400 if (ret != 0) { 401 LOGE("HcfCipherCreate failed!"); 402 goto CLEAR_UP; 403 } 404 405 ret = AesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 406 if (ret != 0) { 407 LOGE("AesNoUpdateEncrypt failed! %d", ret); 408 goto CLEAR_UP; 409 } 410 411 ret = memcmp(cipherText, codeCipherText, cipherTextLen); 412 if (ret != 0) { 413 LOGE("cipherText compare failed!"); 414 goto CLEAR_UP; 415 } 416 417 ret = AesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 418 if (ret != 0) { 419 LOGE("AesNoUpdateDecrypt failed! %d", ret); 420 goto CLEAR_UP; 421 } 422 423 CLEAR_UP: 424 HcfObjDestroy((HcfObjectBase *)key); 425 HcfObjDestroy((HcfObjectBase *)cipher); 426 EXPECT_EQ(ret, 0); 427 } 428 429 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest009, TestSize.Level0) 430 { 431 int ret = 0; 432 HcfCipher *cipher = nullptr; 433 HcfSymKey *key = nullptr; 434 435 ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); 436 if (ret != 0) { 437 LOGE("GeneratorFile failed!"); 438 goto CLEAR_UP; 439 } 440 ret = ConvertSymKey("AES128", &key); 441 if (ret != 0) { 442 LOGE("ConvertSymKey failed!"); 443 goto CLEAR_UP; 444 } 445 446 ret = HcfCipherCreate("AES128|ECB|NoPadding", &cipher); 447 if (ret != 0) { 448 LOGE("HcfCipherCreate failed!"); 449 goto CLEAR_UP; 450 } 451 452 ret = AesMultiBlockEncrypt(cipher, key, nullptr); 453 if (ret != 0) { 454 LOGE("AesNoUpdateEncrypt failed! %d", ret); 455 goto CLEAR_UP; 456 } 457 458 ret = AesMultiBlockDecrypt(cipher, key, nullptr); 459 if (ret != 0) { 460 LOGE("AesNoUpdateDecrypt failed! %d", ret); 461 goto CLEAR_UP; 462 } 463 ret = CompareFileContent(); 464 if (ret != 0) { 465 LOGE("CompareFileContent failed!"); 466 goto CLEAR_UP; 467 } 468 469 CLEAR_UP: 470 HcfObjDestroy((HcfObjectBase *)key); 471 HcfObjDestroy((HcfObjectBase *)cipher); 472 EXPECT_EQ(ret, 0); 473 } 474 475 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest010, TestSize.Level0) 476 { 477 int ret = 0; 478 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 479 int cipherTextLen = CIPHER_TEXT_LEN; 480 HcfCipher *cipher = nullptr; 481 HcfSymKey *key = nullptr; 482 483 ret = GenerateSymKey("AES192", &key); 484 if (ret != 0) { 485 LOGE("GenerateSymKey failed!"); 486 goto CLEAR_UP; 487 } 488 489 ret = HcfCipherCreate("AES192|ECB|NoPadding", &cipher); 490 if (ret != 0) { 491 LOGE("HcfCipherCreate failed!"); 492 goto CLEAR_UP; 493 } 494 495 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 496 if (ret != 0) { 497 LOGE("AesEncrypt failed! %d", ret); 498 goto CLEAR_UP; 499 } 500 501 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 502 if (ret != 0) { 503 LOGE("AesDecrypt failed! %d", ret); 504 } 505 CLEAR_UP: 506 HcfObjDestroy(key); 507 HcfObjDestroy(cipher); 508 EXPECT_NE(ret, 0); 509 } 510 511 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest011, TestSize.Level0) 512 { 513 int ret = 0; 514 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 515 int cipherTextLen = CIPHER_TEXT_LEN; 516 HcfCipher *cipher = nullptr; 517 HcfSymKey *key = nullptr; 518 519 ret = GenerateSymKey("AES192", &key); 520 if (ret != 0) { 521 LOGE("GenerateSymKey failed!"); 522 goto CLEAR_UP; 523 } 524 525 ret = HcfCipherCreate("AES192|ECB|PKCS5", &cipher); 526 if (ret != 0) { 527 LOGE("HcfCipherCreate failed!"); 528 goto CLEAR_UP; 529 } 530 531 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 532 if (ret != 0) { 533 LOGE("AesEncrypt failed! %d", ret); 534 goto CLEAR_UP; 535 } 536 537 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 538 if (ret != 0) { 539 LOGE("AesDecrypt failed! %d", ret); 540 } 541 key->clearMem(key); 542 CLEAR_UP: 543 HcfObjDestroy(key); 544 HcfObjDestroy(cipher); 545 EXPECT_EQ(ret, 0); 546 } 547 548 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest012, TestSize.Level0) 549 { 550 int ret = 0; 551 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 552 int cipherTextLen = CIPHER_TEXT_LEN; 553 HcfCipher *cipher = nullptr; 554 HcfSymKey *key = nullptr; 555 556 ret = GenerateSymKey("AES256", &key); 557 if (ret != 0) { 558 LOGE("GenerateSymKey failed!"); 559 goto CLEAR_UP; 560 } 561 562 ret = HcfCipherCreate("AES256|ECB|PKCS7", &cipher); 563 if (ret != 0) { 564 LOGE("HcfCipherCreate failed!"); 565 goto CLEAR_UP; 566 } 567 568 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 569 if (ret != 0) { 570 LOGE("AesEncrypt failed! %d", ret); 571 goto CLEAR_UP; 572 } 573 574 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 575 if (ret != 0) { 576 LOGE("AesDecrypt failed! %d", ret); 577 } 578 key->clearMem(key); 579 CLEAR_UP: 580 HcfObjDestroy(key); 581 HcfObjDestroy(cipher); 582 EXPECT_EQ(ret, 0); 583 } 584 585 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest013, TestSize.Level0) 586 { 587 int ret = 0; 588 HcfSymKeyGenerator *generator = nullptr; 589 HcfSymKey *key = nullptr; 590 HcfCipher *cipher = nullptr; 591 592 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 593 if (ret != 0) { 594 LOGE("HcfCipherCreate failed!"); 595 goto CLEAR_UP; 596 } 597 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 598 if (ret != 0) { 599 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 600 goto CLEAR_UP; 601 } 602 ret = generator->generateSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &key); 603 if (ret != 0) { 604 LOGE("generateSymKey failed!"); 605 } 606 607 CLEAR_UP: 608 HcfObjDestroy(key); 609 HcfObjDestroy(generator); 610 HcfObjDestroy(cipher); 611 EXPECT_NE(ret, 0); 612 } 613 614 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest014, TestSize.Level0) 615 { 616 int ret = 0; 617 HcfSymKeyGenerator *generator = nullptr; 618 HcfSymKey *key = nullptr; 619 uint8_t keyMaterial[] = { 620 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 621 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 622 }; 623 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 624 HcfCipher *cipher = nullptr; 625 626 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 627 if (ret != 0) { 628 LOGE("HcfCipherCreate failed!"); 629 goto CLEAR_UP; 630 } 631 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 632 if (ret != 0) { 633 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 634 goto CLEAR_UP; 635 } 636 637 ret = generator->convertSymKey(reinterpret_cast<HcfSymKeyGenerator *>(cipher), &keyTmpBlob, &key); 638 if (ret != 0) { 639 LOGE("generateSymKey failed!"); 640 } 641 642 CLEAR_UP: 643 HcfObjDestroy(key); 644 HcfObjDestroy(generator); 645 HcfObjDestroy(cipher); 646 EXPECT_NE(ret, 0); 647 } 648 649 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest015, TestSize.Level0) 650 { 651 int ret = 0; 652 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 653 int cipherTextLen = CIPHER_TEXT_LEN; 654 HcfCipher *cipher = nullptr; 655 HcfSymKey *key = nullptr; 656 657 ret = GenerateSymKey("AES128", &key); 658 if (ret != 0) { 659 LOGE("GenerateSymKey failed!"); 660 goto CLEAR_UP; 661 } 662 663 // allow input with more than one padding mode. It will pick the last PKCS5. 664 ret = HcfCipherCreate("AES128|ECB|NoPadding|PKCS5", &cipher); 665 if (ret != 0) { 666 LOGE("HcfCipherCreate failed!"); 667 goto CLEAR_UP; 668 } 669 670 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 671 if (ret != 0) { 672 LOGE("AesEncrypt failed! %d", ret); 673 goto CLEAR_UP; 674 } 675 676 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 677 if (ret != 0) { 678 LOGE("AesDecrypt failed! %d", ret); 679 } 680 CLEAR_UP: 681 HcfObjDestroy(key); 682 HcfObjDestroy(cipher); 683 EXPECT_EQ(ret, 0); 684 } 685 686 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest016, TestSize.Level0) 687 { 688 int ret = 0; 689 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 690 int cipherTextLen = CIPHER_TEXT_LEN; 691 HcfCipher *cipher = nullptr; 692 HcfSymKey *key = nullptr; 693 694 ret = GenerateSymKey("AES128", &key); 695 if (ret != 0) { 696 LOGE("GenerateSymKey failed!"); 697 goto CLEAR_UP; 698 } 699 700 ret = HcfCipherCreate("AES256|ECB|PKCS5", &cipher); 701 if (ret != 0) { 702 LOGE("HcfCipherCreate failed!"); 703 goto CLEAR_UP; 704 } 705 706 // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key. 707 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 708 if (ret != 0) { 709 LOGE("AesEncrypt failed! %d", ret); 710 goto CLEAR_UP; 711 } 712 713 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 714 if (ret != 0) { 715 LOGE("AesDecrypt failed! %d", ret); 716 } 717 718 CLEAR_UP: 719 HcfObjDestroy(key); 720 HcfObjDestroy(cipher); 721 EXPECT_EQ(ret, 0); 722 } 723 724 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest017, TestSize.Level0) 725 { 726 int ret = 0; 727 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 728 int cipherTextLen = CIPHER_TEXT_LEN; 729 HcfCipher *cipher = nullptr; 730 HcfSymKey *key = nullptr; 731 732 ret = GenerateSymKey("AES256", &key); 733 if (ret != 0) { 734 LOGE("GenerateSymKey failed!"); 735 goto CLEAR_UP; 736 } 737 738 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 739 if (ret != 0) { 740 LOGE("HcfCipherCreate failed!"); 741 goto CLEAR_UP; 742 } 743 744 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 745 if (ret != 0) { 746 LOGE("AesEncrypt failed! %d", ret); 747 goto CLEAR_UP; 748 } 749 750 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 751 if (ret != 0) { 752 LOGE("AesDecrypt failed! %d", ret); 753 } 754 755 CLEAR_UP: 756 HcfObjDestroy(key); 757 HcfObjDestroy(cipher); 758 EXPECT_EQ(ret, 0); 759 } 760 761 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest018, TestSize.Level0) 762 { 763 int ret = 0; 764 HcfCipher *cipher = nullptr; 765 HcfSymKey *key = nullptr; 766 767 ret = GenerateSymKey("AES128", &key); 768 if (ret != 0) { 769 LOGE("GenerateSymKey failed!"); 770 goto CLEAR_UP; 771 } 772 773 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 774 if (ret != 0) { 775 LOGE("HcfCipherCreate failed!"); 776 goto CLEAR_UP; 777 } 778 779 ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr); 780 if (ret != 0) { 781 LOGE("init failed! Should input cipher when init."); 782 } 783 784 CLEAR_UP: 785 HcfObjDestroy(key); 786 HcfObjDestroy(cipher); 787 EXPECT_NE(ret, 0); 788 } 789 790 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest019, TestSize.Level0) 791 { 792 int ret = 0; 793 HcfSymKeyGenerator *generator = nullptr; 794 HcfCipher *cipher = nullptr; 795 796 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 797 if (ret != 0) { 798 LOGE("HcfCipherCreate failed!"); 799 goto CLEAR_UP; 800 } 801 802 ret = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr); 803 if (ret != 0) { 804 LOGE("init failed! Should input key when init."); 805 } 806 807 CLEAR_UP: 808 HcfObjDestroy(cipher); 809 HcfObjDestroy(generator); 810 EXPECT_NE(ret, 0); 811 } 812 813 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest020, TestSize.Level0) 814 { 815 int ret = 0; 816 HcfSymKeyGenerator *generator = nullptr; 817 HcfSymKey *key = nullptr; 818 HcfCipher *cipher = nullptr; 819 820 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 821 if (ret != 0) { 822 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 823 goto CLEAR_UP; 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|ECB|PKCS5", &cipher); 832 if (ret != 0) { 833 LOGE("HcfCipherCreate failed!"); 834 goto CLEAR_UP; 835 } 836 837 ret = cipher->init(reinterpret_cast<HcfCipher *>(generator), ENCRYPT_MODE, &(key->key), nullptr); 838 if (ret != 0) { 839 LOGE("init failed! Should input key when init."); 840 } 841 842 CLEAR_UP: 843 HcfObjDestroy(key); 844 HcfObjDestroy(cipher); 845 HcfObjDestroy(generator); 846 EXPECT_NE(ret, 0); 847 } 848 849 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest021, TestSize.Level0) 850 { 851 int ret = 0; 852 HcfCipher *cipher = nullptr; 853 HcfSymKey *key = nullptr; 854 uint8_t plainText[] = "this is test!"; 855 HcfBlob input = { .data = plainText, .len = 0 }; 856 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 857 int cipherTextLen = CIPHER_TEXT_LEN; 858 859 ret = GenerateSymKey("AES128", &key); 860 if (ret != 0) { 861 LOGE("generateSymKey failed!"); 862 goto CLEAR_UP; 863 } 864 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 865 if (ret != 0) { 866 LOGE("HcfCipherCreate failed!"); 867 goto CLEAR_UP; 868 } 869 870 ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen); 871 if (ret != 0) { 872 LOGE("AesEncrypt failed! %d", ret); 873 goto CLEAR_UP; 874 } 875 876 ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); 877 if (ret != 0) { 878 LOGE("AesDecrypt failed! %d", ret); 879 } 880 881 CLEAR_UP: 882 HcfObjDestroy(key); 883 HcfObjDestroy(cipher); 884 EXPECT_EQ(ret, 0); 885 } 886 887 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest022, TestSize.Level0) 888 { 889 int ret = 0; 890 HcfCipher *cipher = nullptr; 891 HcfSymKey *key = nullptr; 892 HcfBlob input = { .data = nullptr, .len = 0 }; 893 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 894 int cipherTextLen = CIPHER_TEXT_LEN; 895 896 ret = GenerateSymKey("AES128", &key); 897 if (ret != 0) { 898 LOGE("generateSymKey failed!"); 899 goto CLEAR_UP; 900 } 901 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 902 if (ret != 0) { 903 LOGE("HcfCipherCreate failed!"); 904 goto CLEAR_UP; 905 } 906 907 ret = AesEncryptWithInput(cipher, key, &input, cipherText, &cipherTextLen); 908 if (ret != 0) { 909 LOGE("AesEncrypt failed! %d", ret); 910 goto CLEAR_UP; 911 } 912 913 ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); 914 if (ret != 0) { 915 LOGE("AesDecrypt failed! %d", ret); 916 } 917 918 CLEAR_UP: 919 HcfObjDestroy(key); 920 HcfObjDestroy(cipher); 921 EXPECT_EQ(ret, 0); 922 } 923 924 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest023, TestSize.Level0) 925 { 926 int ret = 0; 927 HcfCipher *cipher = nullptr; 928 HcfSymKey *key = nullptr; 929 HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN }; 930 HcfBlob output = { .data = nullptr, .len = 0 }; 931 932 ret = GenerateSymKey("AES128", &key); 933 if (ret != 0) { 934 LOGE("generateSymKey failed!"); 935 goto CLEAR_UP; 936 } 937 938 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 939 if (ret != 0) { 940 LOGE("HcfCipherCreate failed!"); 941 goto CLEAR_UP; 942 } 943 944 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); 945 if (ret != 0) { 946 LOGE("init failed!"); 947 goto CLEAR_UP; 948 } 949 950 ret = cipher->update(nullptr, &input, &output); 951 if (ret != 0) { 952 LOGE("update failed! Blob data should not be nullptr."); 953 } 954 955 CLEAR_UP: 956 HcfObjDestroy(key); 957 HcfObjDestroy(cipher); 958 if (output.data != nullptr) { 959 HcfFree(output.data); 960 output.data = nullptr; 961 } 962 EXPECT_NE(ret, 0); 963 } 964 965 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest024, TestSize.Level0) 966 { 967 int ret = 0; 968 HcfCipher *cipher = nullptr; 969 HcfSymKey *key = nullptr; 970 HcfBlob input = { .data = nullptr, .len = PLAINTEXT_LEN }; 971 HcfBlob output = { .data = nullptr, .len = 0 }; 972 973 ret = GenerateSymKey("AES128", &key); 974 if (ret != 0) { 975 LOGE("generateSymKey failed!"); 976 goto CLEAR_UP; 977 } 978 979 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 980 if (ret != 0) { 981 LOGE("HcfCipherCreate failed!"); 982 goto CLEAR_UP; 983 } 984 985 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); 986 if (ret != 0) { 987 LOGE("init failed!"); 988 goto CLEAR_UP; 989 } 990 991 ret = cipher->update(reinterpret_cast<HcfCipher *>(key), &input, &output); 992 if (ret != 0) { 993 LOGE("update failed! Blob data should not be nullptr."); 994 } 995 996 CLEAR_UP: 997 HcfObjDestroy(key); 998 HcfObjDestroy(cipher); 999 if (output.data != nullptr) { 1000 HcfFree(output.data); 1001 output.data = nullptr; 1002 } 1003 EXPECT_NE(ret, 0); 1004 } 1005 1006 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest025, TestSize.Level0) 1007 { 1008 int ret = 0; 1009 HcfCipher *cipher = nullptr; 1010 HcfSymKey *key = nullptr; 1011 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 1012 int cipherTextLen = CIPHER_TEXT_LEN; 1013 1014 ret = GenerateSymKey("AES128", &key); 1015 if (ret != 0) { 1016 LOGE("generateSymKey failed!"); 1017 goto CLEAR_UP; 1018 } 1019 1020 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 1021 if (ret != 0) { 1022 LOGE("HcfCipherCreate failed!"); 1023 goto CLEAR_UP; 1024 } 1025 1026 ret = AesNoUpdateEncWithInput(cipher, key, nullptr, cipherText, &cipherTextLen); 1027 if (ret != 0) { 1028 LOGE("AesEncrypt failed! %d", ret); 1029 goto CLEAR_UP; 1030 } 1031 1032 ret = AesDecryptEmptyMsg(cipher, key, nullptr, cipherText, cipherTextLen); 1033 if (ret != 0) { 1034 LOGE("AesDecrypt failed! %d", ret); 1035 } 1036 1037 CLEAR_UP: 1038 HcfObjDestroy(key); 1039 HcfObjDestroy(cipher); 1040 EXPECT_EQ(ret, 0); 1041 } 1042 1043 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest026, TestSize.Level0) 1044 { 1045 int ret = 0; 1046 HcfCipher *cipher = nullptr; 1047 HcfSymKey *key = nullptr; 1048 uint8_t plainText[] = "this is test!"; 1049 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; 1050 1051 ret = GenerateSymKey("AES128", &key); 1052 if (ret != 0) { 1053 LOGE("generateSymKey failed!"); 1054 goto CLEAR_UP; 1055 } 1056 1057 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 1058 if (ret != 0) { 1059 LOGE("HcfCipherCreate failed!"); 1060 goto CLEAR_UP; 1061 } 1062 1063 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); 1064 if (ret != 0) { 1065 LOGE("init failed!"); 1066 goto CLEAR_UP; 1067 } 1068 1069 ret = cipher->doFinal(cipher, &input, nullptr); 1070 if (ret != 0) { 1071 LOGE("update failed! Blob data should not be nullptr."); 1072 } 1073 1074 CLEAR_UP: 1075 HcfObjDestroy(key); 1076 HcfObjDestroy(cipher); 1077 EXPECT_NE(ret, 0); 1078 } 1079 1080 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest027, TestSize.Level0) 1081 { 1082 int ret = 0; 1083 HcfCipher *cipher = nullptr; 1084 HcfSymKey *key = nullptr; 1085 uint8_t plainText[] = "this is test!"; 1086 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN }; 1087 HcfBlob output = { .data = nullptr, .len = 0 }; 1088 1089 ret = GenerateSymKey("AES128", &key); 1090 if (ret != 0) { 1091 LOGE("generateSymKey failed!"); 1092 goto CLEAR_UP; 1093 } 1094 1095 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 1096 if (ret != 0) { 1097 LOGE("HcfCipherCreate failed!"); 1098 goto CLEAR_UP; 1099 } 1100 1101 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr); 1102 if (ret != 0) { 1103 LOGE("init failed!"); 1104 goto CLEAR_UP; 1105 } 1106 1107 ret = cipher->doFinal(reinterpret_cast<HcfCipher *>(key), &input, &output); 1108 if (ret != 0) { 1109 LOGE("update failed! Blob data should not be nullptr."); 1110 } 1111 1112 CLEAR_UP: 1113 HcfObjDestroy(key); 1114 HcfObjDestroy(cipher); 1115 if (output.data != nullptr) { 1116 HcfFree(output.data); 1117 output.data = nullptr; 1118 } 1119 EXPECT_NE(ret, 0); 1120 } 1121 1122 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest028, TestSize.Level0) 1123 { 1124 int ret = 0; 1125 HcfSymKeyGeneratorSpi *generator = nullptr; 1126 HcfSymKey *key = nullptr; 1127 HcfCipher *cipher = nullptr; 1128 SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; 1129 1130 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 1131 if (ret != 0) { 1132 LOGE("HcfCipherCreate failed!"); 1133 goto CLEAR_UP; 1134 } 1135 ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); 1136 if (ret != 0) { 1137 LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); 1138 goto CLEAR_UP; 1139 } 1140 ret = generator->engineGenerateSymmKey(reinterpret_cast<HcfSymKeyGeneratorSpi *>(cipher), &key); 1141 if (ret != 0) { 1142 LOGE("engineGenerateSymmKey failed!"); 1143 } 1144 1145 CLEAR_UP: 1146 HcfObjDestroy(key); 1147 HcfObjDestroy(generator); 1148 HcfObjDestroy(cipher); 1149 EXPECT_NE(ret, 0); 1150 } 1151 1152 HWTEST_F(CryptoAesEcbCipherTest, CryptoAesEcbCipherTest029, TestSize.Level0) 1153 { 1154 int ret = 0; 1155 HcfSymKeyGeneratorSpi *generator = nullptr; 1156 HcfSymKey *key = nullptr; 1157 uint8_t keyMaterial[] = { 1158 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 1159 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 1160 }; 1161 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 1162 HcfCipher *cipher = nullptr; 1163 SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; 1164 1165 ret = HcfCipherCreate("AES128|ECB|PKCS5", &cipher); 1166 if (ret != 0) { 1167 LOGE("HcfCipherCreate failed!"); 1168 goto CLEAR_UP; 1169 } 1170 ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); 1171 if (ret != 0) { 1172 LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); 1173 goto CLEAR_UP; 1174 } 1175 ret = generator->engineConvertSymmKey(reinterpret_cast<HcfSymKeyGeneratorSpi *>(cipher), &keyTmpBlob, &key); 1176 if (ret != 0) { 1177 LOGE("engineConvertSymmKey failed!"); 1178 } 1179 1180 CLEAR_UP: 1181 HcfObjDestroy(key); 1182 HcfObjDestroy(generator); 1183 HcfObjDestroy(cipher); 1184 EXPECT_NE(ret, 0); 1185 } 1186 }