1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include <fstream> 18 #include <iostream> 19 #include "securec.h" 20 #include "aes_openssl.h" 21 #include "aes_common.h" 22 #include "blob.h" 23 #include "cipher.h" 24 #include "detailed_iv_params.h" 25 #include "detailed_gcm_params.h" 26 #include "detailed_ccm_params.h" 27 #include "log.h" 28 #include "memory.h" 29 #include "sym_common_defines.h" 30 #include "sym_key_generator.h" 31 #include "sm4_common.h" 32 #include "sm4_openssl.h" 33 34 using namespace std; 35 using namespace testing::ext; 36 37 namespace { 38 class CryptoSM4CfbCipherTest : public testing::Test { 39 public: SetUpTestCase()40 static void SetUpTestCase() {}; TearDownTestCase()41 static void TearDownTestCase() {}; SetUp()42 void SetUp() {}; TearDown()43 void TearDown() {}; 44 }; 45 46 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest010, TestSize.Level0) 47 { 48 int ret = 0; 49 uint8_t cipherText[128] = {0}; 50 int cipherTextLen = 128; 51 52 HcfSymKeyGenerator *generator = nullptr; 53 HcfCipher *cipher = nullptr; 54 HcfSymKey *key = nullptr; 55 56 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 57 ASSERT_EQ(ret, 0); 58 59 ret = generator->generateSymKey(generator, &key); 60 ASSERT_EQ(ret, 0); 61 62 ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher); 63 ASSERT_EQ(ret, 0); 64 65 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 66 ASSERT_EQ(ret, 0); 67 68 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 69 ASSERT_EQ(ret, 0); 70 71 HcfObjDestroy((HcfObjectBase *)key); 72 HcfObjDestroy((HcfObjectBase *)cipher); 73 HcfObjDestroy((HcfObjectBase *)generator); 74 } 75 76 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest011, TestSize.Level0) 77 { 78 int ret = 0; 79 uint8_t cipherText[128] = {0}; 80 int cipherTextLen = 128; 81 82 HcfSymKeyGenerator *generator = nullptr; 83 HcfCipher *cipher = nullptr; 84 HcfSymKey *key = nullptr; 85 86 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 87 ASSERT_EQ(ret, 0); 88 89 ret = generator->generateSymKey(generator, &key); 90 ASSERT_EQ(ret, 0); 91 92 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 93 ASSERT_EQ(ret, 0); 94 95 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 96 ASSERT_EQ(ret, 0); 97 98 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 99 ASSERT_EQ(ret, 0); 100 101 HcfObjDestroy((HcfObjectBase *)key); 102 HcfObjDestroy((HcfObjectBase *)cipher); 103 HcfObjDestroy((HcfObjectBase *)generator); 104 } 105 106 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest012, TestSize.Level0) 107 { 108 int ret = 0; 109 uint8_t cipherText[128] = {0}; 110 int cipherTextLen = 128; 111 112 HcfSymKeyGenerator *generator = nullptr; 113 HcfCipher *cipher = nullptr; 114 HcfSymKey *key = nullptr; 115 116 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 117 ASSERT_EQ(ret, 0); 118 119 ret = generator->generateSymKey(generator, &key); 120 ASSERT_EQ(ret, 0); 121 122 ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher); 123 ASSERT_EQ(ret, 0); 124 125 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 126 ASSERT_EQ(ret, 0); 127 128 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 129 ASSERT_EQ(ret, 0); 130 131 HcfObjDestroy((HcfObjectBase *)key); 132 HcfObjDestroy((HcfObjectBase *)cipher); 133 HcfObjDestroy((HcfObjectBase *)generator); 134 } 135 136 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest013, TestSize.Level0) 137 { 138 int ret = 0; 139 uint8_t cipherText[128] = {0}; 140 int cipherTextLen = 128; 141 142 HcfSymKeyGenerator *generator = nullptr; 143 HcfCipher *cipher = nullptr; 144 HcfSymKey *key = nullptr; 145 146 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 147 ASSERT_EQ(ret, 0); 148 149 ret = generator->generateSymKey(generator, &key); 150 ASSERT_EQ(ret, 0); 151 152 ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher); 153 ASSERT_EQ(ret, 0); 154 155 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 156 ASSERT_EQ(ret, 0); 157 158 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 159 ASSERT_EQ(ret, 0); 160 161 HcfObjDestroy((HcfObjectBase *)key); 162 HcfObjDestroy((HcfObjectBase *)cipher); 163 HcfObjDestroy((HcfObjectBase *)generator); 164 } 165 166 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest014, TestSize.Level0) 167 { 168 int ret = 0; 169 uint8_t cipherText[128] = {0}; 170 int cipherTextLen = 128; 171 172 HcfSymKeyGenerator *generator = nullptr; 173 HcfCipher *cipher = nullptr; 174 HcfSymKey *key = nullptr; 175 176 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 177 ASSERT_EQ(ret, 0); 178 179 ret = generator->generateSymKey(generator, &key); 180 ASSERT_EQ(ret, 0); 181 182 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 183 ASSERT_EQ(ret, 0); 184 185 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 186 ASSERT_EQ(ret, 0); 187 188 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 189 ASSERT_EQ(ret, 0); 190 191 HcfObjDestroy((HcfObjectBase *)key); 192 HcfObjDestroy((HcfObjectBase *)cipher); 193 HcfObjDestroy((HcfObjectBase *)generator); 194 } 195 196 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest015, TestSize.Level0) 197 { 198 int ret = 0; 199 uint8_t cipherText[128] = {0}; 200 int cipherTextLen = 128; 201 202 HcfSymKeyGenerator *generator = nullptr; 203 HcfCipher *cipher = nullptr; 204 HcfSymKey *key = nullptr; 205 206 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 207 ASSERT_EQ(ret, 0); 208 209 ret = generator->generateSymKey(generator, &key); 210 ASSERT_EQ(ret, 0); 211 212 ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher); 213 ASSERT_EQ(ret, 0); 214 215 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 216 ASSERT_EQ(ret, 0); 217 218 ret = Sm4Decrypt(cipher, key, nullptr, cipherText, cipherTextLen); 219 ASSERT_EQ(ret, 0); 220 221 HcfObjDestroy((HcfObjectBase *)key); 222 HcfObjDestroy((HcfObjectBase *)cipher); 223 HcfObjDestroy((HcfObjectBase *)generator); 224 } 225 226 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest028, TestSize.Level0) 227 { 228 int ret = 0; 229 uint8_t cipherText[128] = {0}; 230 int cipherTextLen = 128; 231 232 HcfSymKeyGenerator *generator = nullptr; 233 HcfCipher *cipher = nullptr; 234 HcfSymKey *key = nullptr; 235 236 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 237 ASSERT_EQ(ret, 0); 238 239 ret = generator->generateSymKey(generator, &key); 240 ASSERT_EQ(ret, 0); 241 242 ret = HcfCipherCreate("SM4_128|CFB|NoPadding", &cipher); 243 ASSERT_EQ(ret, 0); 244 245 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 246 ASSERT_EQ(ret, 0); 247 248 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 249 ASSERT_EQ(ret, 0); 250 251 HcfObjDestroy((HcfObjectBase *)key); 252 HcfObjDestroy((HcfObjectBase *)cipher); 253 HcfObjDestroy((HcfObjectBase *)generator); 254 } 255 256 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest029, TestSize.Level0) 257 { 258 int ret = 0; 259 uint8_t cipherText[128] = {0}; 260 int cipherTextLen = 128; 261 262 HcfSymKeyGenerator *generator = nullptr; 263 HcfCipher *cipher = nullptr; 264 HcfSymKey *key = nullptr; 265 266 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 267 ASSERT_EQ(ret, 0); 268 269 ret = generator->generateSymKey(generator, &key); 270 ASSERT_EQ(ret, 0); 271 272 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 273 ASSERT_EQ(ret, 0); 274 275 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 276 ASSERT_EQ(ret, 0); 277 278 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 279 ASSERT_EQ(ret, 0); 280 281 HcfObjDestroy((HcfObjectBase *)key); 282 HcfObjDestroy((HcfObjectBase *)cipher); 283 HcfObjDestroy((HcfObjectBase *)generator); 284 } 285 286 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest030, TestSize.Level0) 287 { 288 int ret = 0; 289 uint8_t cipherText[128] = {0}; 290 int cipherTextLen = 128; 291 292 HcfSymKeyGenerator *generator = nullptr; 293 HcfCipher *cipher = nullptr; 294 HcfSymKey *key = nullptr; 295 296 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 297 ASSERT_EQ(ret, 0); 298 299 ret = generator->generateSymKey(generator, &key); 300 ASSERT_EQ(ret, 0); 301 302 ret = HcfCipherCreate("SM4_128|CFB|PKCS7", &cipher); 303 ASSERT_EQ(ret, 0); 304 305 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 306 ASSERT_EQ(ret, 0); 307 308 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 309 ASSERT_EQ(ret, 0); 310 311 HcfObjDestroy((HcfObjectBase *)key); 312 HcfObjDestroy((HcfObjectBase *)cipher); 313 HcfObjDestroy((HcfObjectBase *)generator); 314 } 315 316 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest031, TestSize.Level0) 317 { 318 int ret = 0; 319 uint8_t cipherText[128] = {0}; 320 int cipherTextLen = 128; 321 322 HcfSymKeyGenerator *generator = nullptr; 323 HcfCipher *cipher = nullptr; 324 HcfSymKey *key = nullptr; 325 326 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 327 ASSERT_EQ(ret, 0); 328 329 ret = generator->generateSymKey(generator, &key); 330 ASSERT_EQ(ret, 0); 331 332 ret = HcfCipherCreate("SM4_128|CFB128|NoPadding", &cipher); 333 ASSERT_EQ(ret, 0); 334 335 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 336 ASSERT_EQ(ret, 0); 337 338 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 339 ASSERT_EQ(ret, 0); 340 341 HcfObjDestroy((HcfObjectBase *)key); 342 HcfObjDestroy((HcfObjectBase *)cipher); 343 HcfObjDestroy((HcfObjectBase *)generator); 344 } 345 346 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest032, TestSize.Level0) 347 { 348 int ret = 0; 349 uint8_t cipherText[128] = {0}; 350 int cipherTextLen = 128; 351 352 HcfSymKeyGenerator *generator = nullptr; 353 HcfCipher *cipher = nullptr; 354 HcfSymKey *key = nullptr; 355 356 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 357 ASSERT_EQ(ret, 0); 358 359 ret = generator->generateSymKey(generator, &key); 360 ASSERT_EQ(ret, 0); 361 362 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 363 ASSERT_EQ(ret, 0); 364 365 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 366 ASSERT_EQ(ret, 0); 367 368 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 369 ASSERT_EQ(ret, 0); 370 371 HcfObjDestroy((HcfObjectBase *)key); 372 HcfObjDestroy((HcfObjectBase *)cipher); 373 HcfObjDestroy((HcfObjectBase *)generator); 374 } 375 376 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest033, TestSize.Level0) 377 { 378 int ret = 0; 379 uint8_t cipherText[128] = {0}; 380 int cipherTextLen = 128; 381 382 HcfSymKeyGenerator *generator = nullptr; 383 HcfCipher *cipher = nullptr; 384 HcfSymKey *key = nullptr; 385 386 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 387 ASSERT_EQ(ret, 0); 388 389 ret = generator->generateSymKey(generator, &key); 390 ASSERT_EQ(ret, 0); 391 392 ret = HcfCipherCreate("SM4_128|CFB128|PKCS7", &cipher); 393 ASSERT_EQ(ret, 0); 394 395 ret = Sm4NoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 396 ASSERT_EQ(ret, 0); 397 398 ret = Sm4NoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen); 399 ASSERT_EQ(ret, 0); 400 401 HcfObjDestroy((HcfObjectBase *)key); 402 HcfObjDestroy((HcfObjectBase *)cipher); 403 HcfObjDestroy((HcfObjectBase *)generator); 404 } 405 406 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest040, TestSize.Level0) 407 { 408 HcfCipher *cipher = nullptr; 409 const char *cipherName = "SM4_128|CFB|NoPadding"; 410 const char *retAlgo = nullptr; 411 412 int ret = HcfCipherCreate(cipherName, &cipher); 413 ASSERT_EQ(ret, 0); 414 415 retAlgo = cipher->getAlgorithm(nullptr); 416 ASSERT_EQ(retAlgo, nullptr); 417 418 HcfObjDestroy(cipher); 419 } 420 421 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest041, TestSize.Level0) 422 { 423 HcfCipher *cipher = nullptr; 424 HcfSymKeyGenerator *generator = nullptr; 425 const char *cipherName = "SM4_128|CFB|NoPadding"; 426 const char *retAlgo = nullptr; 427 428 int ret = HcfSymKeyGeneratorCreate("SM4_128", &generator); 429 ASSERT_EQ(ret, 0); 430 431 ret = HcfCipherCreate(cipherName, &cipher); 432 ASSERT_EQ(ret, 0); 433 434 retAlgo = cipher->getAlgorithm(reinterpret_cast<HcfCipher *>(generator)); 435 ASSERT_EQ(retAlgo, nullptr); 436 437 HcfObjDestroy(generator); 438 HcfObjDestroy(cipher); 439 } 440 441 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest042, TestSize.Level0) 442 { 443 HcfCipher *cipher = nullptr; 444 int ret = HcfCipherCreate("SM3|CFB|NoPadding", &cipher); 445 ASSERT_NE(ret, 0); 446 HcfObjDestroy(cipher); 447 } 448 449 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest043, TestSize.Level0) 450 { 451 HcfCipher *cipher = nullptr; 452 int ret = HcfCipherCreate("SM4_128|CFB|", &cipher); 453 ASSERT_NE(ret, 0); 454 HcfObjDestroy(cipher); 455 } 456 457 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest047, TestSize.Level0) 458 { 459 int ret = HcfCipherCreate(nullptr, nullptr); 460 ASSERT_NE(ret, 0); 461 } 462 463 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest050, TestSize.Level0) 464 { 465 uint8_t aad[8] = {0}; 466 uint8_t tag[12] = {0}; 467 uint8_t iv[16] = {0}; 468 uint8_t cipherText[128] = {0}; 469 int cipherTextLen = 128; 470 471 HcfCipher *cipher = nullptr; 472 HcfSymKey *key = nullptr; 473 HcfCcmParamsSpec spec = {}; 474 spec.aad.data = aad; 475 spec.aad.len = sizeof(aad); 476 spec.tag.data = tag; 477 spec.tag.len = sizeof(tag); 478 spec.iv.data = iv; 479 spec.iv.len = sizeof(iv); 480 481 int ret = GenerateSymKeyForSm4("SM4_128", &key); 482 ASSERT_EQ(ret, 0); 483 484 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 485 ASSERT_EQ(ret, 0); 486 487 ret = Sm4Encrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, &cipherTextLen); 488 ASSERT_EQ(ret, 0); 489 490 (void)memcpy_s(spec.tag.data, 12, cipherText + cipherTextLen - 12, 12); 491 cipherTextLen -= 12; 492 493 ret = Sm4Decrypt(cipher, key, (HcfParamsSpec *)&spec, cipherText, cipherTextLen); 494 ASSERT_NE(ret, 0); 495 496 HcfObjDestroy((HcfObjectBase *)key); 497 HcfObjDestroy((HcfObjectBase *)cipher); 498 } 499 500 HWTEST_F(CryptoSM4CfbCipherTest, CryptoAesCipherTest051, TestSize.Level0) 501 { 502 HcfCipher *cipher = nullptr; 503 const char *cipherName = "SM4_128|CFB|NoPadding"; 504 const char *retAlgo = nullptr; 505 506 int ret = HcfCipherCreate(cipherName, &cipher); 507 ASSERT_EQ(ret, 0); 508 509 retAlgo = cipher->getAlgorithm(cipher); 510 ASSERT_NE(retAlgo, nullptr); 511 512 ret = strcmp(retAlgo, cipherName); 513 ASSERT_EQ(ret, 0); 514 515 HcfObjDestroy(cipher); 516 } 517 518 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest082, TestSize.Level0) 519 { 520 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 521 int cipherTextLen = CIPHER_TEXT_LEN; 522 HcfCipher *cipher = nullptr; 523 HcfSymKey *key = nullptr; 524 525 int ret = GenerateSymKeyForSm4("AES256", &key); 526 ASSERT_EQ(ret, 0); 527 528 ret = HcfCipherCreate("SM4_128|CFB|PKCS5", &cipher); 529 ASSERT_EQ(ret, 0); 530 531 // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key. 532 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 533 ASSERT_NE(ret, 0); 534 535 HcfObjDestroy(key); 536 HcfObjDestroy(cipher); 537 } 538 539 HWTEST_F(CryptoSM4CfbCipherTest, CryptoSm4CipherTest083, TestSize.Level0) 540 { 541 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 542 int cipherTextLen = CIPHER_TEXT_LEN; 543 HcfCipher *cipher = nullptr; 544 HcfSymKey *key = nullptr; 545 546 int ret = GenerateSymKeyForSm4("AES256", &key); 547 ASSERT_EQ(ret, 0); 548 549 ret = HcfCipherCreate("SM4_128|CFB128|PKCS5", &cipher); 550 ASSERT_EQ(ret, 0); 551 552 // It is not allowed that AES128 in key is smaller AES256 in cipher. -> now only use the size of input key. 553 ret = Sm4Encrypt(cipher, key, nullptr, cipherText, &cipherTextLen); 554 ASSERT_NE(ret, 0); 555 556 HcfObjDestroy(key); 557 HcfObjDestroy(cipher); 558 } 559 }