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 CryptoAesCipherTest : 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(CryptoAesCipherTest, CryptoAesCipherTest001, TestSize.Level0) 46 { 47 int ret = 0; 48 HcfSymKeyGenerator *generator = nullptr; 49 HcfSymKey *key = nullptr; 50 const char *inputAlgoName = "AES128"; 51 const char *generatorAlgoName = nullptr; 52 53 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); 54 if (ret != 0) { 55 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 56 goto CLEAR_UP; 57 } 58 ret = generator->generateSymKey(generator, &key); 59 if (ret != 0) { 60 LOGE("generateSymKey failed!"); 61 goto CLEAR_UP; 62 } 63 64 // generator getAlgoName 65 generatorAlgoName = generator->getAlgoName(generator); 66 if (generatorAlgoName == nullptr) { 67 LOGE("generator getAlgoName returns nullptr."); 68 ret = HCF_ERR_CRYPTO_OPERATION; 69 goto CLEAR_UP; 70 } 71 72 ret = strcmp(generatorAlgoName, inputAlgoName); 73 if (ret != 0) { 74 LOGE("generator getAlgoName failed!"); 75 } 76 CLEAR_UP: 77 HcfObjDestroy(key); 78 HcfObjDestroy(generator); 79 EXPECT_EQ(ret, 0); 80 } 81 82 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest002, TestSize.Level0) 83 { 84 int ret = 0; 85 HcfSymKeyGenerator *generator = nullptr; 86 const char *generatorAlgoName = nullptr; 87 const char *inputAlgoName = "AES128"; 88 89 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); 90 if (ret != 0) { 91 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 92 goto CLEAR_UP; 93 } 94 95 // generator getAlgoName 96 generatorAlgoName = generator->getAlgoName(nullptr); 97 if (generatorAlgoName == nullptr) { 98 LOGE("generator getAlgoName failed!"); 99 ret = HCF_ERR_CRYPTO_OPERATION; 100 } 101 102 CLEAR_UP: 103 HcfObjDestroy(generator); 104 EXPECT_NE(ret, 0); 105 } 106 107 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest003, TestSize.Level0) 108 { 109 int ret = 0; 110 HcfSymKeyGenerator *generator = nullptr; 111 HcfSymKey *key = nullptr; 112 const char *generatorAlgoName = nullptr; 113 const char *inputAlgoName = "AES128"; 114 115 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); 116 if (ret != 0) { 117 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 118 goto CLEAR_UP; 119 } 120 ret = generator->generateSymKey(generator, &key); 121 if (ret != 0) { 122 LOGE("generateSymKey failed!"); 123 goto CLEAR_UP; 124 } 125 126 // generator getAlgoName 127 generatorAlgoName = generator->getAlgoName(reinterpret_cast<HcfSymKeyGenerator *>(key)); 128 if (generatorAlgoName == nullptr) { 129 LOGE("generator getAlgoName failed!"); 130 ret = HCF_ERR_CRYPTO_OPERATION; 131 } 132 133 CLEAR_UP: 134 HcfObjDestroy(key); 135 HcfObjDestroy(generator); 136 EXPECT_NE(ret, 0); 137 } 138 139 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest004, TestSize.Level0) 140 { 141 int ret = 0; 142 HcfSymKey *key = nullptr; 143 const char *inputAlgoName = "AES128"; 144 const char *keyAlgoName = nullptr; 145 146 ret = GenerateSymKey(inputAlgoName, &key); 147 if (ret != 0) { 148 LOGE("GenerateSymKey failed!"); 149 goto CLEAR_UP; 150 } 151 152 // key getAlgorithm 153 keyAlgoName = key->key.getAlgorithm(&(key->key)); 154 if (keyAlgoName == nullptr) { 155 LOGE("key getAlgorithm returns nullptr."); 156 ret = HCF_ERR_CRYPTO_OPERATION; 157 goto CLEAR_UP; 158 } 159 160 ret = strcmp(keyAlgoName, inputAlgoName); 161 if (ret != 0) { 162 LOGE("key getAlgorithm failed!"); 163 } 164 CLEAR_UP: 165 HcfObjDestroy(key); 166 EXPECT_EQ(ret, 0); 167 } 168 169 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest005, TestSize.Level0) 170 { 171 int ret = 0; 172 HcfSymKey *key = nullptr; 173 const char *inputAlgoName = "AES128"; 174 const char *keyAlgoName = nullptr; 175 176 ret = GenerateSymKey(inputAlgoName, &key); 177 if (ret != 0) { 178 LOGE("GenerateSymKey failed!"); 179 goto CLEAR_UP; 180 } 181 182 // key getAlgorithm 183 keyAlgoName = key->key.getAlgorithm(nullptr); 184 if (keyAlgoName == nullptr) { 185 LOGE("key getAlgorithm returns nullptr."); 186 ret = HCF_ERR_CRYPTO_OPERATION; 187 } 188 189 CLEAR_UP: 190 HcfObjDestroy(key); 191 EXPECT_NE(ret, 0); 192 } 193 194 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest006, TestSize.Level0) 195 { 196 int ret = 0; 197 HcfSymKeyGenerator *generator = nullptr; 198 HcfSymKey *key = nullptr; 199 const char *inputAlgoName = "AES128"; 200 const char *keyAlgoName = nullptr; 201 202 ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator); 203 if (ret != 0) { 204 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 205 goto CLEAR_UP; 206 } 207 ret = generator->generateSymKey(generator, &key); 208 if (ret != 0) { 209 LOGE("generateSymKey failed!"); 210 goto CLEAR_UP; 211 } 212 213 // key getAlgorithm 214 keyAlgoName = key->key.getAlgorithm(reinterpret_cast<HcfKey *>(generator)); 215 if (keyAlgoName == nullptr) { 216 LOGE("key getAlgorithm returns nullptr."); 217 ret = HCF_ERR_CRYPTO_OPERATION; 218 } 219 220 CLEAR_UP: 221 HcfObjDestroy(key); 222 HcfObjDestroy(generator); 223 EXPECT_NE(ret, 0); 224 } 225 226 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest007, TestSize.Level0) 227 { 228 int ret = 0; 229 HcfSymKey *key = nullptr; 230 const char *keyFormat = "PKCS#8"; 231 const char *retFormat = nullptr; 232 233 ret = GenerateSymKey("AES128", &key); 234 if (ret != 0) { 235 LOGE("GenerateSymKey failed!"); 236 goto CLEAR_UP; 237 } 238 239 // key GetFormat 240 retFormat = key->key.getFormat(&(key->key)); 241 if (retFormat == nullptr) { 242 LOGE("key GetFormat returns nullptr."); 243 ret = HCF_ERR_CRYPTO_OPERATION; 244 goto CLEAR_UP; 245 } 246 247 ret = strcmp(retFormat, keyFormat); 248 if (ret != 0) { 249 LOGE("key GetFormat failed!"); 250 } 251 252 CLEAR_UP: 253 HcfObjDestroy(key); 254 EXPECT_EQ(ret, 0); 255 } 256 257 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest008, TestSize.Level0) 258 { 259 int ret = 0; 260 HcfSymKey *key = nullptr; 261 const char *retFormat = nullptr; 262 263 ret = GenerateSymKey("AES128", &key); 264 if (ret != 0) { 265 LOGE("GenerateSymKey failed!"); 266 goto CLEAR_UP; 267 } 268 269 // key getFormat 270 retFormat = key->key.getFormat(nullptr); 271 if (retFormat == nullptr) { 272 LOGE("key GetFormat returns nullptr."); 273 ret = HCF_ERR_CRYPTO_OPERATION; 274 } 275 276 CLEAR_UP: 277 HcfObjDestroy(key); 278 EXPECT_NE(ret, 0); 279 } 280 281 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest009, TestSize.Level0) 282 { 283 int ret = 0; 284 HcfSymKeyGenerator *generator = nullptr; 285 HcfSymKey *key = nullptr; 286 const char *retFormat = nullptr; 287 288 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 289 if (ret != 0) { 290 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 291 goto CLEAR_UP; 292 } 293 ret = generator->generateSymKey(generator, &key); 294 if (ret != 0) { 295 LOGE("generateSymKey failed!"); 296 goto CLEAR_UP; 297 } 298 299 // key getFormat 300 retFormat = key->key.getFormat(reinterpret_cast<HcfKey *>(generator)); 301 if (retFormat == nullptr) { 302 LOGE("key GetFormat returns nullptr."); 303 ret = HCF_ERR_CRYPTO_OPERATION; 304 } 305 306 CLEAR_UP: 307 HcfObjDestroy(key); 308 HcfObjDestroy(generator); 309 EXPECT_NE(ret, 0); 310 } 311 312 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest010, TestSize.Level0) 313 { 314 int ret = 0; 315 HcfSymKeyGenerator *generator = nullptr; 316 HcfSymKey *key = nullptr; 317 HcfBlob encodedBlob = { 0 }; 318 uint8_t keyMaterial[] = { 319 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 320 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 321 }; 322 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 323 324 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 325 if (ret != 0) { 326 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 327 goto CLEAR_UP; 328 } 329 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 330 if (ret != 0) { 331 LOGE("generateSymKey failed!"); 332 goto CLEAR_UP; 333 } 334 335 // key getEncoded 336 ret = key->key.getEncoded(&(key->key), &encodedBlob); 337 if (ret != 0) { 338 LOGE("key GetEncoded failed."); 339 goto CLEAR_UP; 340 } 341 342 if (encodedBlob.len != keyTmpBlob.len) { 343 LOGE("key GetEncoded failed!"); 344 ret = HCF_ERR_CRYPTO_OPERATION; 345 goto CLEAR_UP; 346 } 347 ret = memcmp(encodedBlob.data, keyTmpBlob.data, keyTmpBlob.len); 348 349 CLEAR_UP: 350 HcfObjDestroy(key); 351 HcfObjDestroy(generator); 352 if (encodedBlob.data != nullptr) { 353 HcfFree(encodedBlob.data); 354 encodedBlob.data = nullptr; 355 } 356 EXPECT_EQ(ret, 0); 357 } 358 359 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest011, TestSize.Level0) 360 { 361 int ret = 0; 362 HcfSymKeyGenerator *generator = nullptr; 363 HcfSymKey *key = nullptr; 364 HcfBlob encodedBlob = { 0 }; 365 uint8_t keyMaterial[] = { 366 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 367 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 368 }; 369 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 370 371 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 372 if (ret != 0) { 373 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 374 goto CLEAR_UP; 375 } 376 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 377 if (ret != 0) { 378 LOGE("generateSymKey failed!"); 379 goto CLEAR_UP; 380 } 381 382 // key getEncoded 383 ret = key->key.getEncoded(nullptr, &encodedBlob); 384 if (ret != 0) { 385 LOGE("key GetEncoded failed."); 386 } 387 388 CLEAR_UP: 389 HcfObjDestroy(key); 390 HcfObjDestroy(generator); 391 if (encodedBlob.data != nullptr) { 392 HcfFree(encodedBlob.data); 393 encodedBlob.data = nullptr; 394 } 395 EXPECT_NE(ret, 0); 396 } 397 398 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest012, TestSize.Level0) 399 { 400 int ret = 0; 401 HcfSymKeyGenerator *generator = nullptr; 402 HcfSymKey *key = nullptr; 403 HcfBlob encodedBlob = { 0 }; 404 uint8_t keyMaterial[] = { 405 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 406 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 407 }; 408 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 409 410 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 411 if (ret != 0) { 412 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 413 goto CLEAR_UP; 414 } 415 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 416 if (ret != 0) { 417 LOGE("generateSymKey failed!"); 418 goto CLEAR_UP; 419 } 420 421 // key getEncoded 422 ret = key->key.getEncoded(reinterpret_cast<HcfKey *>(generator), &encodedBlob); 423 if (ret != 0) { 424 LOGE("key GetEncoded failed."); 425 } 426 427 CLEAR_UP: 428 HcfObjDestroy(key); 429 HcfObjDestroy(generator); 430 if (encodedBlob.data != nullptr) { 431 HcfFree(encodedBlob.data); 432 encodedBlob.data = nullptr; 433 } 434 EXPECT_NE(ret, 0); 435 } 436 437 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest013, TestSize.Level0) 438 { 439 int ret = 0; 440 HcfSymKeyGenerator *generator = nullptr; 441 HcfSymKey *key = nullptr; 442 HcfBlob encodedBlob = { 0 }; 443 uint8_t keyMaterial[] = { 444 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 445 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 446 }; 447 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 448 SymKeyImpl *impl = nullptr; 449 size_t tmpLen = 0; 450 451 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 452 if (ret != 0) { 453 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 454 goto CLEAR_UP; 455 } 456 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 457 if (ret != 0) { 458 LOGE("generateSymKey failed!"); 459 goto CLEAR_UP; 460 } 461 impl = reinterpret_cast<SymKeyImpl *>(key); 462 tmpLen = impl->keyMaterial.len; 463 impl->keyMaterial.len = 0; 464 465 // key getEncoded 466 ret = key->key.getEncoded(&(key->key), &encodedBlob); 467 impl->keyMaterial.len = tmpLen; 468 if (ret != 0) { 469 LOGE("key GetEncoded failed."); 470 } 471 472 CLEAR_UP: 473 HcfObjDestroy(key); 474 HcfObjDestroy(generator); 475 if (encodedBlob.data != nullptr) { 476 HcfFree(encodedBlob.data); 477 encodedBlob.data = nullptr; 478 } 479 EXPECT_NE(ret, 0); 480 } 481 482 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest014, TestSize.Level0) 483 { 484 int ret = 0; 485 HcfSymKeyGenerator *generator = nullptr; 486 HcfSymKey *key = nullptr; 487 HcfBlob encodedBlob = { 0 }; 488 uint8_t keyMaterial[] = { 489 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 490 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 491 }; 492 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 493 494 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 495 if (ret != 0) { 496 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 497 goto CLEAR_UP; 498 } 499 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 500 if (ret != 0) { 501 LOGE("generateSymKey failed!"); 502 goto CLEAR_UP; 503 } 504 505 key->clearMem(nullptr); 506 507 ret = key->key.getEncoded(&(key->key), &encodedBlob); 508 if (ret != 0) { 509 LOGE("key GetEncoded failed."); 510 goto CLEAR_UP; 511 } 512 if ((encodedBlob.data != nullptr) && (encodedBlob.data[0] != '\0')) { 513 LOGE("clearMem failed!"); 514 ret = HCF_ERR_CRYPTO_OPERATION; 515 } 516 517 CLEAR_UP: 518 HcfObjDestroy(key); 519 HcfObjDestroy(generator); 520 if (encodedBlob.data != nullptr) { 521 HcfFree(encodedBlob.data); 522 encodedBlob.data = nullptr; 523 } 524 EXPECT_NE(ret, 0); 525 } 526 527 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest015, TestSize.Level0) 528 { 529 int ret = 0; 530 HcfSymKeyGenerator *generator = nullptr; 531 532 ret = HcfSymKeyGeneratorCreate("RSA128", &generator); 533 if (ret != 0) { 534 LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator."); 535 } 536 537 HcfObjDestroy(generator); 538 EXPECT_NE(ret, 0); 539 } 540 541 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest016, TestSize.Level0) 542 { 543 int ret = 0; 544 HcfSymKeyGenerator *generator = nullptr; 545 546 ret = HcfSymKeyGeneratorCreate("RSA512", &generator); 547 if (ret != 0) { 548 LOGE("HcfSymKeyGeneratorCreate failed! Should not select RSA for symKey generator."); 549 } 550 551 HcfObjDestroy(generator); 552 EXPECT_NE(ret, 0); 553 } 554 555 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest017, TestSize.Level0) 556 { 557 int ret = 0; 558 HcfSymKeyGenerator *generator = nullptr; 559 560 ret = HcfSymKeyGeneratorCreate("", &generator); 561 if (ret != 0) { 562 LOGE("HcfSymKeyGeneratorCreate failed! Should not select empty string for symKey generator."); 563 } 564 565 HcfObjDestroy(generator); 566 EXPECT_NE(ret, 0); 567 } 568 569 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest018, TestSize.Level0) 570 { 571 int ret = 0; 572 HcfSymKeyGenerator *generator = nullptr; 573 574 ret = HcfSymKeyGeneratorCreate(nullptr, &generator); 575 if (ret != 0) { 576 LOGE("HcfSymKeyGeneratorCreate failed! Should not select nullptr for symKey generator."); 577 } 578 579 HcfObjDestroy(generator); 580 EXPECT_NE(ret, 0); 581 } 582 583 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest019, TestSize.Level0) 584 { 585 int ret = 0; 586 HcfSymKeyGenerator *generator = nullptr; 587 588 ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr); 589 if (ret != 0) { 590 LOGE("HcfSymKeyGeneratorSpiCreate failed!"); 591 } 592 593 HcfObjDestroy(generator); 594 EXPECT_NE(ret, 0); 595 } 596 597 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest020, TestSize.Level0) 598 { 599 int ret = 0; 600 HcfSymKeyGenerator *generator = nullptr; 601 HcfSymKey *key = nullptr; 602 603 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 604 if (ret != 0) { 605 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 606 goto CLEAR_UP; 607 } 608 ret = generator->generateSymKey(nullptr, &key); 609 if (ret != 0) { 610 LOGE("generateSymKey failed!"); 611 } 612 613 CLEAR_UP: 614 HcfObjDestroy(key); 615 HcfObjDestroy(generator); 616 EXPECT_NE(ret, 0); 617 } 618 619 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest021, TestSize.Level0) 620 { 621 int ret = 0; 622 HcfSymKeyGenerator *generator = nullptr; 623 HcfSymKey *key = nullptr; 624 uint8_t keyMaterial[] = { 625 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 626 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 627 }; 628 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 629 630 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 631 if (ret != 0) { 632 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 633 goto CLEAR_UP; 634 } 635 636 ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key); 637 if (ret != 0) { 638 LOGE("generateSymKey failed!"); 639 } 640 641 CLEAR_UP: 642 HcfObjDestroy(key); 643 HcfObjDestroy(generator); 644 EXPECT_NE(ret, 0); 645 } 646 647 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest022, TestSize.Level0) 648 { 649 int ret = 0; 650 HcfSymKeyGenerator *generator = nullptr; 651 HcfSymKey *key = nullptr; 652 uint8_t keyMaterial[] = { 653 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 654 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 655 }; 656 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 }; 657 658 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 659 if (ret != 0) { 660 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 661 goto CLEAR_UP; 662 } 663 664 ret = generator->convertSymKey(generator, &keyTmpBlob, &key); 665 if (ret != 0) { 666 LOGE("generateSymKey failed!"); 667 } 668 669 CLEAR_UP: 670 HcfObjDestroy(key); 671 HcfObjDestroy(generator); 672 EXPECT_NE(ret, 0); 673 } 674 675 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest023, TestSize.Level0) 676 { 677 int ret = 0; 678 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 679 int cipherTextLen = CIPHER_TEXT_LEN; 680 HcfCipher *cipher = nullptr; 681 HcfSymKey *key = nullptr; 682 683 ret = GenerateSymKey("AES128", &key); 684 if (ret != 0) { 685 LOGE("GenerateSymKey failed!"); 686 goto CLEAR_UP; 687 } 688 689 // allow input without encryption mode. It will pick the last PKCS5, and use default aes128ecb. 690 ret = HcfCipherCreate("AES128|NoPadding|PKCS5", &cipher); 691 if (ret != 0) { 692 LOGE("HcfCipherCreate failed!"); 693 goto CLEAR_UP; 694 } 695 696 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 697 if (ret != 0) { 698 LOGE("AesEncrypt failed! %d", ret); 699 goto CLEAR_UP; 700 } 701 702 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 703 if (ret != 0) { 704 LOGE("AesDecrypt failed! %d", ret); 705 } 706 CLEAR_UP: 707 HcfObjDestroy(key); 708 HcfObjDestroy(cipher); 709 EXPECT_EQ(ret, 0); 710 } 711 712 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest024, TestSize.Level0) 713 { 714 int ret = 0; 715 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 716 int cipherTextLen = CIPHER_TEXT_LEN; 717 HcfCipher *cipher = nullptr; 718 HcfSymKey *key = nullptr; 719 720 ret = GenerateSymKey("AES128", &key); 721 if (ret != 0) { 722 LOGE("GenerateSymKey failed!"); 723 goto CLEAR_UP; 724 } 725 726 // allow input without encryption mode. It will use default aes128ecb. 727 ret = HcfCipherCreate("AES128|PKCS5", &cipher); 728 if (ret != 0) { 729 LOGE("HcfCipherCreate failed!"); 730 goto CLEAR_UP; 731 } 732 733 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 734 if (ret != 0) { 735 LOGE("AesEncrypt failed! %d", ret); 736 goto CLEAR_UP; 737 } 738 739 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 740 if (ret != 0) { 741 LOGE("AesDecrypt failed! %d", ret); 742 } 743 CLEAR_UP: 744 HcfObjDestroy(key); 745 HcfObjDestroy(cipher); 746 EXPECT_EQ(ret, 0); 747 } 748 749 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0) 750 { 751 int ret = 0; 752 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 753 int cipherTextLen = CIPHER_TEXT_LEN; 754 HcfCipher *cipher = nullptr; 755 HcfSymKey *key = nullptr; 756 757 ret = GenerateSymKey("AES128", &key); 758 if (ret != 0) { 759 LOGE("GenerateSymKey failed!"); 760 goto CLEAR_UP; 761 } 762 763 // allow input without encryption mode. It will use default aes128ecb. 764 ret = HcfCipherCreate("AES128", &cipher); 765 if (ret != 0) { 766 LOGE("HcfCipherCreate failed!"); 767 goto CLEAR_UP; 768 } 769 770 ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 771 if (ret != 0) { 772 LOGE("AesEncrypt failed! %d", ret); 773 goto CLEAR_UP; 774 } 775 776 ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 777 if (ret != 0) { 778 LOGE("AesDecrypt failed! %d", ret); 779 } 780 CLEAR_UP: 781 HcfObjDestroy(key); 782 HcfObjDestroy(cipher); 783 EXPECT_EQ(ret, 0); 784 } 785 786 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0) 787 { 788 int ret = 0; 789 HcfCipher *cipher = nullptr; 790 791 ret = HcfCipherCreate("", &cipher); 792 if (ret != 0) { 793 LOGE("HcfCipherCreate failed!"); 794 } 795 796 HcfObjDestroy(cipher); 797 EXPECT_NE(ret, 0); 798 } 799 800 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0) 801 { 802 int ret = 0; 803 HcfCipher *cipher = nullptr; 804 805 ret = HcfCipherCreate(nullptr, &cipher); 806 if (ret != 0) { 807 LOGE("HcfCipherCreate failed!"); 808 } 809 810 HcfObjDestroy(cipher); 811 EXPECT_NE(ret, 0); 812 } 813 814 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0) 815 { 816 int ret = HcfCipherAesGeneratorSpiCreate(nullptr, nullptr); 817 if (ret != 0) { 818 LOGE("HcfCipherAesGeneratorSpiCreate failed!"); 819 } 820 EXPECT_NE(ret, 0); 821 822 HcfCipherGeneratorSpi *cipher = nullptr; 823 CipherAttr params = { 824 .algo = HCF_ALG_AES, 825 .mode = HCF_ALG_MODE_ECB, 826 .paddingMode = HCF_ALG_PADDING_PKCS5, 827 }; 828 ret = HcfCipherAesGeneratorSpiCreate(¶ms, &cipher); 829 EXPECT_EQ(ret, HCF_SUCCESS); 830 831 ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr); 832 EXPECT_EQ(ret, HCF_INVALID_PARAMS); 833 834 ret = cipher->update(nullptr, nullptr, nullptr); 835 EXPECT_EQ(ret, HCF_INVALID_PARAMS); 836 837 ret = cipher->doFinal(nullptr, nullptr, nullptr); 838 EXPECT_EQ(ret, HCF_INVALID_PARAMS); 839 840 HcfBlob dataArray = { .data = nullptr, .len = 0 }; 841 ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr); 842 EXPECT_EQ(ret, HCF_NOT_SUPPORT); 843 844 ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray); 845 EXPECT_EQ(ret, HCF_NOT_SUPPORT); 846 847 HcfBlob dataUint8 = { .data = nullptr, .len = 0 }; 848 ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8); 849 EXPECT_EQ(ret, HCF_NOT_SUPPORT); 850 851 (void)cipher->base.destroy(nullptr); 852 853 HcfObjDestroy(cipher); 854 HcfBlobDataFree(&dataArray); 855 } 856 857 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0) 858 { 859 int ret = 0; 860 HcfSymKeyGeneratorSpi *generator = nullptr; 861 HcfSymKey *key = nullptr; 862 SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; 863 864 ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); 865 if (ret != 0) { 866 LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); 867 goto CLEAR_UP; 868 } 869 ret = generator->engineGenerateSymmKey(nullptr, &key); 870 if (ret != 0) { 871 LOGE("engineGenerateSymmKey failed!"); 872 } 873 874 CLEAR_UP: 875 HcfObjDestroy(key); 876 HcfObjDestroy(generator); 877 EXPECT_NE(ret, 0); 878 } 879 880 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0) 881 { 882 int ret = 0; 883 HcfSymKeyGeneratorSpi *generator = nullptr; 884 HcfSymKey *key = nullptr; 885 uint8_t keyMaterial[] = { 886 0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56, 887 0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c 888 }; 889 HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN }; 890 SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE }; 891 892 ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator); 893 if (ret != 0) { 894 LOGE("HcfSymKeyGeneratorSpiCreate failed!%d", ret); 895 goto CLEAR_UP; 896 } 897 ret = generator->engineConvertSymmKey(nullptr, &keyTmpBlob, &key); 898 if (ret != 0) { 899 LOGE("engineConvertSymmKey failed!"); 900 } 901 902 CLEAR_UP: 903 HcfObjDestroy(key); 904 HcfObjDestroy(generator); 905 EXPECT_NE(ret, 0); 906 } 907 }