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 CryptoAesCtrCipherTest : 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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest001, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest002, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest003, 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|CTR|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 191 CLEAR_UP: 192 HcfObjDestroy((HcfObjectBase *)key); 193 HcfObjDestroy((HcfObjectBase *)cipher); 194 HcfObjDestroy((HcfObjectBase *)generator); 195 EXPECT_EQ(ret, 0); 196 } 197 198 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest004, TestSize.Level0) 199 { 200 int ret = 0; 201 uint8_t iv[16] = {0}; 202 uint8_t cipherText[128] = {0}; 203 int cipherTextLen = 128; 204 205 HcfIvParamsSpec ivSpec = {}; 206 HcfSymKeyGenerator *generator = nullptr; 207 HcfCipher *cipher = nullptr; 208 HcfSymKey *key = nullptr; 209 ivSpec.iv.data = iv; 210 ivSpec.iv.len = 16; 211 212 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 213 if (ret != 0) { 214 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 215 goto CLEAR_UP; 216 } 217 218 ret = generator->generateSymKey(generator, &key); 219 if (ret != 0) { 220 LOGE("generateSymKey failed!"); 221 goto CLEAR_UP; 222 } 223 224 ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher); 225 if (ret != 0) { 226 LOGE("HcfCipherCreate failed!"); 227 goto CLEAR_UP; 228 } 229 230 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 231 if (ret != 0) { 232 LOGE("AesNoUpdateEncrypt failed! %d", ret); 233 goto CLEAR_UP; 234 } 235 236 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 237 if (ret != 0) { 238 LOGE("AesNoUpdateDecrypt failed! %d", ret); 239 goto CLEAR_UP; 240 } 241 242 CLEAR_UP: 243 HcfObjDestroy((HcfObjectBase *)key); 244 HcfObjDestroy((HcfObjectBase *)cipher); 245 HcfObjDestroy((HcfObjectBase *)generator); 246 EXPECT_EQ(ret, 0); 247 } 248 249 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest005, TestSize.Level0) 250 { 251 int ret = 0; 252 uint8_t iv[16] = {0}; 253 uint8_t cipherText[128] = {0}; 254 int cipherTextLen = 128; 255 256 HcfIvParamsSpec ivSpec = {}; 257 HcfSymKeyGenerator *generator = nullptr; 258 HcfCipher *cipher = nullptr; 259 HcfSymKey *key = nullptr; 260 ivSpec.iv.data = iv; 261 ivSpec.iv.len = 16; 262 263 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 264 if (ret != 0) { 265 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 266 goto CLEAR_UP; 267 } 268 269 ret = generator->generateSymKey(generator, &key); 270 if (ret != 0) { 271 LOGE("generateSymKey failed!"); 272 goto CLEAR_UP; 273 } 274 275 ret = HcfCipherCreate("AES128|CTR|PKCS5", &cipher); 276 if (ret != 0) { 277 LOGE("HcfCipherCreate failed!"); 278 goto CLEAR_UP; 279 } 280 281 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 282 if (ret != 0) { 283 LOGE("AesNoUpdateEncrypt failed! %d", ret); 284 goto CLEAR_UP; 285 } 286 287 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 288 if (ret != 0) { 289 LOGE("AesNoUpdateDecrypt failed! %d", ret); 290 goto CLEAR_UP; 291 } 292 293 CLEAR_UP: 294 HcfObjDestroy((HcfObjectBase *)key); 295 HcfObjDestroy((HcfObjectBase *)cipher); 296 HcfObjDestroy((HcfObjectBase *)generator); 297 EXPECT_EQ(ret, 0); 298 } 299 300 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest006, TestSize.Level0) 301 { 302 int ret = 0; 303 uint8_t iv[16] = {0}; 304 uint8_t cipherText[128] = {0}; 305 int cipherTextLen = 128; 306 307 HcfIvParamsSpec ivSpec = {}; 308 HcfSymKeyGenerator *generator = nullptr; 309 HcfCipher *cipher = nullptr; 310 HcfSymKey *key = nullptr; 311 ivSpec.iv.data = iv; 312 ivSpec.iv.len = 16; 313 314 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 315 if (ret != 0) { 316 LOGE("HcfSymKeyGeneratorCreate failed!%d", ret); 317 goto CLEAR_UP; 318 } 319 320 ret = generator->generateSymKey(generator, &key); 321 if (ret != 0) { 322 LOGE("generateSymKey failed!"); 323 goto CLEAR_UP; 324 } 325 326 ret = HcfCipherCreate("AES128|CTR|PKCS7", &cipher); 327 if (ret != 0) { 328 LOGE("HcfCipherCreate failed!"); 329 goto CLEAR_UP; 330 } 331 332 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 333 if (ret != 0) { 334 LOGE("AesNoUpdateEncrypt failed! %d", ret); 335 goto CLEAR_UP; 336 } 337 338 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 339 if (ret != 0) { 340 LOGE("AesNoUpdateDecrypt failed! %d", ret); 341 goto CLEAR_UP; 342 } 343 344 CLEAR_UP: 345 HcfObjDestroy((HcfObjectBase *)key); 346 HcfObjDestroy((HcfObjectBase *)cipher); 347 HcfObjDestroy((HcfObjectBase *)generator); 348 EXPECT_EQ(ret, 0); 349 } 350 351 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest007, TestSize.Level0) 352 { 353 int ret = 0; 354 uint8_t iv[16] = {0}; 355 356 HcfIvParamsSpec ivSpec = {}; 357 HcfCipher *cipher = nullptr; 358 HcfSymKey *key = nullptr; 359 ivSpec.iv.data = iv; 360 ivSpec.iv.len = 16; 361 362 ret = ConvertSymKey("AES128", &key); 363 if (ret != 0) { 364 LOGE("ConvertSymKey failed!"); 365 goto CLEAR_UP; 366 } 367 368 ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher); 369 if (ret != 0) { 370 LOGE("HcfCipherCreate failed!"); 371 goto CLEAR_UP; 372 } 373 ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); 374 if (ret != 0) { 375 LOGE("GeneratorFile failed!"); 376 goto CLEAR_UP; 377 } 378 379 ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 380 if (ret != 0) { 381 LOGE("AesNoUpdateEncrypt failed! %d", ret); 382 goto CLEAR_UP; 383 } 384 385 ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 386 if (ret != 0) { 387 LOGE("AesNoUpdateDecrypt failed! %d", ret); 388 goto CLEAR_UP; 389 } 390 ret = CompareFileContent(); 391 if (ret != 0) { 392 LOGE("CompareFileContent failed!"); 393 goto CLEAR_UP; 394 } 395 396 CLEAR_UP: 397 HcfObjDestroy((HcfObjectBase *)key); 398 HcfObjDestroy((HcfObjectBase *)cipher); 399 EXPECT_EQ(ret, 0); 400 } 401 402 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest008, TestSize.Level0) 403 { 404 int ret = 0; 405 uint8_t iv[AES_IV_LEN] = { 0 }; 406 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 407 int cipherTextLen = CIPHER_TEXT_LEN; 408 409 HcfIvParamsSpec ivSpec = {}; 410 HcfCipher *cipher = nullptr; 411 HcfSymKey *key = nullptr; 412 ivSpec.iv.data = iv; 413 ivSpec.iv.len = AES_IV_LEN; 414 415 ret = GenerateSymKey("AES192", &key); 416 if (ret != 0) { 417 LOGE("GenerateSymKey failed!"); 418 goto CLEAR_UP; 419 } 420 421 ret = HcfCipherCreate("AES192|CTR|PKCS5", &cipher); 422 if (ret != 0) { 423 LOGE("HcfCipherCreate failed!"); 424 goto CLEAR_UP; 425 } 426 427 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 428 if (ret != 0) { 429 LOGE("AesEncrypt failed! %d", ret); 430 goto CLEAR_UP; 431 } 432 433 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 434 if (ret != 0) { 435 LOGE("AesDecrypt failed! %d", ret); 436 } 437 438 CLEAR_UP: 439 HcfObjDestroy(key); 440 HcfObjDestroy(cipher); 441 EXPECT_EQ(ret, 0); 442 } 443 444 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest009, TestSize.Level0) 445 { 446 int ret = 0; 447 uint8_t iv[AES_IV_LEN] = { 0 }; 448 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 449 int cipherTextLen = CIPHER_TEXT_LEN; 450 451 HcfIvParamsSpec ivSpec = {}; 452 HcfCipher *cipher = nullptr; 453 HcfSymKey *key = nullptr; 454 ivSpec.iv.data = iv; 455 ivSpec.iv.len = AES_IV_LEN; 456 457 ret = GenerateSymKey("AES256", &key); 458 if (ret != 0) { 459 LOGE("GenerateSymKey failed!"); 460 goto CLEAR_UP; 461 } 462 463 ret = HcfCipherCreate("AES256|CTR|PKCS5", &cipher); 464 if (ret != 0) { 465 LOGE("HcfCipherCreate failed!"); 466 goto CLEAR_UP; 467 } 468 469 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 470 if (ret != 0) { 471 LOGE("AesEncrypt failed! %d", ret); 472 goto CLEAR_UP; 473 } 474 475 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 476 if (ret != 0) { 477 LOGE("AesDecrypt failed! %d", ret); 478 } 479 480 CLEAR_UP: 481 HcfObjDestroy(key); 482 HcfObjDestroy(cipher); 483 EXPECT_EQ(ret, 0); 484 } 485 }