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