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 CryptoAesOfbCipherTest : 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(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest001, TestSize.Level0) 46 { 47 int ret = 0; 48 uint8_t iv[16] = {0}; 49 uint8_t cipherText[128] = {0}; 50 int cipherTextLen = 128; 51 52 HcfIvParamsSpec ivSpec = {}; 53 HcfSymKeyGenerator *generator = nullptr; 54 HcfCipher *cipher = nullptr; 55 HcfSymKey *key = nullptr; 56 ivSpec.iv.data = iv; 57 ivSpec.iv.len = 16; 58 59 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 60 if (ret != 0) { 61 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 62 goto CLEAR_UP; 63 } 64 65 ret = generator->generateSymKey(generator, &key); 66 if (ret != 0) { 67 LOGE("generateSymKey failed!"); 68 goto CLEAR_UP; 69 } 70 71 ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); 72 if (ret != 0) { 73 LOGE("HcfCipherCreate failed!"); 74 goto CLEAR_UP; 75 } 76 77 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 78 if (ret != 0) { 79 LOGE("AesEncrypt failed! %d", ret); 80 goto CLEAR_UP; 81 } 82 83 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 84 if (ret != 0) { 85 LOGE("AesDecrypt failed! %d", ret); 86 goto CLEAR_UP; 87 } 88 89 CLEAR_UP: 90 HcfObjDestroy((HcfObjectBase *)key); 91 HcfObjDestroy((HcfObjectBase *)cipher); 92 HcfObjDestroy((HcfObjectBase *)generator); 93 EXPECT_EQ(ret, 0); 94 } 95 96 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest002, TestSize.Level0) 97 { 98 int ret = 0; 99 uint8_t iv[16] = {0}; 100 uint8_t cipherText[128] = {0}; 101 int cipherTextLen = 128; 102 103 HcfIvParamsSpec ivSpec = {}; 104 HcfSymKeyGenerator *generator = nullptr; 105 HcfCipher *cipher = nullptr; 106 HcfSymKey *key = nullptr; 107 ivSpec.iv.data = iv; 108 ivSpec.iv.len = 16; 109 110 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 111 if (ret != 0) { 112 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 113 goto CLEAR_UP; 114 } 115 116 ret = generator->generateSymKey(generator, &key); 117 if (ret != 0) { 118 LOGE("generateSymKey failed!"); 119 goto CLEAR_UP; 120 } 121 122 ret = HcfCipherCreate("AES128|OFB|PKCS5", &cipher); 123 if (ret != 0) { 124 LOGE("HcfCipherCreate failed!"); 125 goto CLEAR_UP; 126 } 127 128 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 129 if (ret != 0) { 130 LOGE("AesEncrypt failed! %d", ret); 131 goto CLEAR_UP; 132 } 133 134 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 135 if (ret != 0) { 136 LOGE("AesDecrypt failed! %d", ret); 137 goto CLEAR_UP; 138 } 139 140 CLEAR_UP: 141 HcfObjDestroy((HcfObjectBase *)key); 142 HcfObjDestroy((HcfObjectBase *)cipher); 143 HcfObjDestroy((HcfObjectBase *)generator); 144 EXPECT_EQ(ret, 0); 145 } 146 147 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest003, TestSize.Level0) 148 { 149 int ret = 0; 150 uint8_t iv[16] = {0}; 151 uint8_t cipherText[128] = {0}; 152 int cipherTextLen = 128; 153 154 HcfIvParamsSpec ivSpec = {}; 155 HcfSymKeyGenerator *generator = nullptr; 156 HcfCipher *cipher = nullptr; 157 HcfSymKey *key = nullptr; 158 ivSpec.iv.data = iv; 159 ivSpec.iv.len = 16; 160 161 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 162 if (ret != 0) { 163 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 164 goto CLEAR_UP; 165 } 166 167 ret = generator->generateSymKey(generator, &key); 168 if (ret != 0) { 169 LOGE("generateSymKey failed!"); 170 goto CLEAR_UP; 171 } 172 173 ret = HcfCipherCreate("AES128|OFB|PKCS7", &cipher); 174 if (ret != 0) { 175 LOGE("HcfCipherCreate failed!"); 176 goto CLEAR_UP; 177 } 178 179 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 180 if (ret != 0) { 181 LOGE("AesEncrypt failed! %d", ret); 182 goto CLEAR_UP; 183 } 184 185 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 186 if (ret != 0) { 187 LOGE("AesDecrypt failed! %d", ret); 188 goto CLEAR_UP; 189 } 190 CLEAR_UP: 191 HcfObjDestroy((HcfObjectBase *)key); 192 HcfObjDestroy((HcfObjectBase *)cipher); 193 HcfObjDestroy((HcfObjectBase *)generator); 194 EXPECT_EQ(ret, 0); 195 } 196 197 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest004, TestSize.Level0) 198 { 199 int ret = 0; 200 uint8_t iv[16] = {0}; 201 uint8_t cipherText[128] = {0}; 202 int cipherTextLen = 128; 203 204 HcfIvParamsSpec ivSpec = {}; 205 HcfSymKeyGenerator *generator = nullptr; 206 HcfCipher *cipher = nullptr; 207 HcfSymKey *key = nullptr; 208 ivSpec.iv.data = iv; 209 ivSpec.iv.len = 16; 210 211 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 212 if (ret != 0) { 213 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 214 goto CLEAR_UP; 215 } 216 217 ret = generator->generateSymKey(generator, &key); 218 if (ret != 0) { 219 LOGE("generateSymKey failed!"); 220 goto CLEAR_UP; 221 } 222 223 ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); 224 if (ret != 0) { 225 LOGE("HcfCipherCreate failed!"); 226 goto CLEAR_UP; 227 } 228 229 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 230 if (ret != 0) { 231 LOGE("AesNoUpdateEncrypt failed! %d", ret); 232 goto CLEAR_UP; 233 } 234 235 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 236 if (ret != 0) { 237 LOGE("AesNoUpdateDecrypt failed! %d", ret); 238 goto CLEAR_UP; 239 } 240 241 CLEAR_UP: 242 HcfObjDestroy((HcfObjectBase *)key); 243 HcfObjDestroy((HcfObjectBase *)cipher); 244 HcfObjDestroy((HcfObjectBase *)generator); 245 EXPECT_EQ(ret, 0); 246 } 247 248 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest005, TestSize.Level0) 249 { 250 int ret = 0; 251 uint8_t iv[16] = {0}; 252 uint8_t cipherText[128] = {0}; 253 int cipherTextLen = 128; 254 255 HcfIvParamsSpec ivSpec = {}; 256 HcfSymKeyGenerator *generator = nullptr; 257 HcfCipher *cipher = nullptr; 258 HcfSymKey *key = nullptr; 259 ivSpec.iv.data = iv; 260 ivSpec.iv.len = 16; 261 262 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 263 if (ret != 0) { 264 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 265 goto CLEAR_UP; 266 } 267 268 ret = generator->generateSymKey(generator, &key); 269 if (ret != 0) { 270 LOGE("generateSymKey failed!"); 271 goto CLEAR_UP; 272 } 273 274 ret = HcfCipherCreate("AES128|OFB|PKCS5", &cipher); 275 if (ret != 0) { 276 LOGE("HcfCipherCreate failed!"); 277 goto CLEAR_UP; 278 } 279 280 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 281 if (ret != 0) { 282 LOGE("AesNoUpdateEncrypt failed! %d", ret); 283 goto CLEAR_UP; 284 } 285 286 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 287 if (ret != 0) { 288 LOGE("AesNoUpdateDecrypt failed! %d", ret); 289 goto CLEAR_UP; 290 } 291 292 CLEAR_UP: 293 HcfObjDestroy((HcfObjectBase *)key); 294 HcfObjDestroy((HcfObjectBase *)cipher); 295 HcfObjDestroy((HcfObjectBase *)generator); 296 EXPECT_EQ(ret, 0); 297 } 298 299 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest006, TestSize.Level0) 300 { 301 int ret = 0; 302 uint8_t iv[16] = {0}; 303 uint8_t cipherText[128] = {0}; 304 int cipherTextLen = 128; 305 306 HcfIvParamsSpec ivSpec = {}; 307 HcfSymKeyGenerator *generator = nullptr; 308 HcfCipher *cipher = nullptr; 309 HcfSymKey *key = nullptr; 310 ivSpec.iv.data = iv; 311 ivSpec.iv.len = 16; 312 313 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 314 if (ret != 0) { 315 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 316 goto CLEAR_UP; 317 } 318 319 ret = generator->generateSymKey(generator, &key); 320 if (ret != 0) { 321 LOGE("generateSymKey failed!"); 322 goto CLEAR_UP; 323 } 324 325 ret = HcfCipherCreate("AES128|OFB|PKCS7", &cipher); 326 if (ret != 0) { 327 LOGE("HcfCipherCreate failed!"); 328 goto CLEAR_UP; 329 } 330 331 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 332 if (ret != 0) { 333 LOGE("AesNoUpdateEncrypt failed! %d", ret); 334 goto CLEAR_UP; 335 } 336 337 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 338 if (ret != 0) { 339 LOGE("AesNoUpdateDecrypt failed! %d", ret); 340 goto CLEAR_UP; 341 } 342 CLEAR_UP: 343 HcfObjDestroy((HcfObjectBase *)key); 344 HcfObjDestroy((HcfObjectBase *)cipher); 345 HcfObjDestroy((HcfObjectBase *)generator); 346 EXPECT_EQ(ret, 0); 347 } 348 349 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest007, TestSize.Level0) 350 { 351 int ret = 0; 352 uint8_t iv[16] = {0}; 353 354 HcfIvParamsSpec ivSpec = {}; 355 HcfCipher *cipher = nullptr; 356 HcfSymKey *key = nullptr; 357 ivSpec.iv.data = iv; 358 ivSpec.iv.len = 16; 359 360 ret = GenerateSymKey("AES128", &key); 361 if (ret != 0) { 362 LOGE("GenerateSymKey failed!"); 363 goto CLEAR_UP; 364 } 365 366 ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher); 367 if (ret != 0) { 368 LOGE("HcfCipherCreate failed!"); 369 goto CLEAR_UP; 370 } 371 ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); 372 if (ret != 0) { 373 LOGE("GeneratorFile failed!"); 374 goto CLEAR_UP; 375 } 376 377 ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 378 if (ret != 0) { 379 LOGE("AesNoUpdateEncrypt failed! %d", ret); 380 goto CLEAR_UP; 381 } 382 383 ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 384 if (ret != 0) { 385 LOGE("AesNoUpdateDecrypt failed! %d", ret); 386 goto CLEAR_UP; 387 } 388 ret = CompareFileContent(); 389 if (ret != 0) { 390 LOGE("CompareFileContent failed!"); 391 goto CLEAR_UP; 392 } 393 394 CLEAR_UP: 395 HcfObjDestroy((HcfObjectBase *)key); 396 HcfObjDestroy((HcfObjectBase *)cipher); 397 EXPECT_EQ(ret, 0); 398 } 399 400 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest008, TestSize.Level0) 401 { 402 int ret = 0; 403 uint8_t iv[AES_IV_LEN] = { 0 }; 404 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 405 int cipherTextLen = CIPHER_TEXT_LEN; 406 407 HcfIvParamsSpec ivSpec = {}; 408 HcfCipher *cipher = nullptr; 409 HcfSymKey *key = nullptr; 410 ivSpec.iv.data = iv; 411 ivSpec.iv.len = AES_IV_LEN; 412 413 ret = GenerateSymKey("AES192", &key); 414 if (ret != 0) { 415 LOGE("GenerateSymKey failed!"); 416 goto CLEAR_UP; 417 } 418 419 ret = HcfCipherCreate("AES192|OFB|PKCS5", &cipher); 420 if (ret != 0) { 421 LOGE("HcfCipherCreate failed!"); 422 goto CLEAR_UP; 423 } 424 425 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 426 if (ret != 0) { 427 LOGE("AesEncrypt failed! %d", ret); 428 goto CLEAR_UP; 429 } 430 431 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 432 if (ret != 0) { 433 LOGE("AesDecrypt failed! %d", ret); 434 } 435 436 CLEAR_UP: 437 HcfObjDestroy(key); 438 HcfObjDestroy(cipher); 439 EXPECT_EQ(ret, 0); 440 } 441 442 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest009, TestSize.Level0) 443 { 444 int ret = 0; 445 uint8_t iv[AES_IV_LEN] = { 0 }; 446 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 447 int cipherTextLen = CIPHER_TEXT_LEN; 448 449 HcfIvParamsSpec ivSpec = {}; 450 HcfCipher *cipher = nullptr; 451 HcfSymKey *key = nullptr; 452 ivSpec.iv.data = iv; 453 ivSpec.iv.len = AES_IV_LEN; 454 455 ret = GenerateSymKey("AES256", &key); 456 if (ret != 0) { 457 LOGE("GenerateSymKey failed!"); 458 goto CLEAR_UP; 459 } 460 461 ret = HcfCipherCreate("AES256|OFB|PKCS5", &cipher); 462 if (ret != 0) { 463 LOGE("HcfCipherCreate failed!"); 464 goto CLEAR_UP; 465 } 466 467 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 468 if (ret != 0) { 469 LOGE("AesEncrypt failed! %d", ret); 470 goto CLEAR_UP; 471 } 472 473 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 474 if (ret != 0) { 475 LOGE("AesDecrypt failed! %d", ret); 476 } 477 478 CLEAR_UP: 479 HcfObjDestroy(key); 480 HcfObjDestroy(cipher); 481 EXPECT_EQ(ret, 0); 482 } 483 }