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 CryptoAesCbcCipherTest : 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(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest001, 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 ASSERT_EQ(ret, 0); 61 62 ret = generator->generateSymKey(generator, &key); 63 ASSERT_EQ(ret, 0); 64 65 ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); 66 ASSERT_EQ(ret, 0); 67 68 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 69 ASSERT_NE(ret, 0); 70 71 HcfObjDestroy((HcfObjectBase *)key); 72 HcfObjDestroy((HcfObjectBase *)cipher); 73 HcfObjDestroy((HcfObjectBase *)generator); 74 } 75 76 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest002, TestSize.Level0) 77 { 78 int ret = 0; 79 uint8_t iv[16] = {0}; 80 uint8_t cipherText[128] = {0}; 81 int cipherTextLen = 128; 82 83 HcfIvParamsSpec ivSpec = {}; 84 HcfSymKeyGenerator *generator = nullptr; 85 HcfCipher *cipher = nullptr; 86 HcfSymKey *key = nullptr; 87 ivSpec.iv.data = iv; 88 ivSpec.iv.len = 16; 89 90 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 91 ASSERT_EQ(ret, 0); 92 93 ret = generator->generateSymKey(generator, &key); 94 ASSERT_EQ(ret, 0); 95 96 ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher); 97 ASSERT_EQ(ret, 0); 98 99 ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 100 ASSERT_EQ(ret, 0); 101 102 ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 103 ASSERT_EQ(ret, 0); 104 105 HcfObjDestroy((HcfObjectBase *)key); 106 HcfObjDestroy((HcfObjectBase *)cipher); 107 HcfObjDestroy((HcfObjectBase *)generator); 108 } 109 110 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest003, TestSize.Level0) 111 { 112 int ret = 0; 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 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|CBC|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(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest004, TestSize.Level0) 145 { 146 int ret = 0; 147 uint8_t iv[16] = {0}; 148 uint8_t cipherText[128] = {0}; 149 int cipherTextLen = 128; 150 151 HcfIvParamsSpec ivSpec = {}; 152 HcfSymKeyGenerator *generator = nullptr; 153 HcfCipher *cipher = nullptr; 154 HcfSymKey *key = nullptr; 155 ivSpec.iv.data = iv; 156 ivSpec.iv.len = 16; 157 158 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 159 ASSERT_EQ(ret, 0); 160 161 ret = generator->generateSymKey(generator, &key); 162 ASSERT_EQ(ret, 0); 163 164 ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); 165 ASSERT_EQ(ret, 0); 166 167 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 168 ASSERT_NE(ret, 0); 169 170 HcfObjDestroy((HcfObjectBase *)key); 171 HcfObjDestroy((HcfObjectBase *)cipher); 172 HcfObjDestroy((HcfObjectBase *)generator); 173 } 174 175 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest005, TestSize.Level0) 176 { 177 int ret = 0; 178 uint8_t iv[16] = {0}; 179 uint8_t cipherText[128] = {0}; 180 int cipherTextLen = 128; 181 182 HcfIvParamsSpec ivSpec = {}; 183 HcfSymKeyGenerator *generator = nullptr; 184 HcfCipher *cipher = nullptr; 185 HcfSymKey *key = nullptr; 186 ivSpec.iv.data = iv; 187 ivSpec.iv.len = 16; 188 189 ret = HcfSymKeyGeneratorCreate("AES128", &generator); 190 ASSERT_EQ(ret, 0); 191 192 ret = generator->generateSymKey(generator, &key); 193 ASSERT_EQ(ret, 0); 194 195 ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher); 196 ASSERT_EQ(ret, 0); 197 198 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 199 ASSERT_EQ(ret, 0); 200 201 ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen); 202 ASSERT_EQ(ret, 0); 203 204 HcfObjDestroy((HcfObjectBase *)key); 205 HcfObjDestroy((HcfObjectBase *)cipher); 206 HcfObjDestroy((HcfObjectBase *)generator); 207 } 208 209 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest006, TestSize.Level0) 210 { 211 int ret = 0; 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 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|CBC|PKCS7", &cipher); 230 ASSERT_EQ(ret, 0); 231 232 ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen); 233 ASSERT_EQ(ret, 0); 234 235 ret = AesNoUpdateDecrypt(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(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest007, TestSize.Level0) 244 { 245 int ret = 0; 246 HcfIvParamsSpec ivSpec = {}; 247 uint8_t iv[16] = {0}; 248 ivSpec.iv.data = iv; 249 ivSpec.iv.len = 16; 250 251 HcfCipher *cipher = nullptr; 252 HcfSymKey *key = nullptr; 253 254 ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE); 255 ASSERT_EQ(ret, 0); 256 257 ret = ConvertSymKey("AES128", &key); 258 ASSERT_EQ(ret, 0); 259 260 ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher); 261 ASSERT_EQ(ret, 0); 262 263 ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 264 ASSERT_EQ(ret, 0); 265 266 ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec); 267 ASSERT_EQ(ret, 0); 268 269 ret = CompareFileContent(); 270 ASSERT_EQ(ret, 0); 271 272 HcfObjDestroy((HcfObjectBase *)key); 273 HcfObjDestroy((HcfObjectBase *)cipher); 274 } 275 276 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest008, TestSize.Level0) 277 { 278 int ret = 0; 279 uint8_t iv[AES_IV_LEN] = { 0 }; 280 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 281 int cipherTextLen = CIPHER_TEXT_LEN; 282 283 HcfIvParamsSpec ivSpec = {}; 284 HcfCipher *cipher = nullptr; 285 HcfSymKey *key = nullptr; 286 ivSpec.iv.data = iv; 287 ivSpec.iv.len = AES_IV_LEN; 288 289 ret = GenerateSymKey("AES192", &key); 290 ASSERT_EQ(ret, 0); 291 292 ret = HcfCipherCreate("AES192|CBC|PKCS5", &cipher); 293 ASSERT_EQ(ret, 0); 294 295 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 296 ASSERT_EQ(ret, 0); 297 298 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 299 ASSERT_EQ(ret, 0); 300 301 HcfObjDestroy(key); 302 HcfObjDestroy(cipher); 303 } 304 305 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest009, TestSize.Level0) 306 { 307 int ret = 0; 308 uint8_t iv[AES_IV_LEN] = { 0 }; 309 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 }; 310 int cipherTextLen = CIPHER_TEXT_LEN; 311 312 HcfIvParamsSpec ivSpec = {}; 313 HcfCipher *cipher = nullptr; 314 HcfSymKey *key = nullptr; 315 ivSpec.iv.data = iv; 316 ivSpec.iv.len = AES_IV_LEN; 317 318 ret = GenerateSymKey("AES256", &key); 319 ASSERT_EQ(ret, 0); 320 321 ret = HcfCipherCreate("AES256|CBC|PKCS5", &cipher); 322 ASSERT_EQ(ret, 0); 323 324 ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen); 325 ASSERT_EQ(ret, 0); 326 327 ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen); 328 ASSERT_EQ(ret, 0); 329 330 HcfObjDestroy(key); 331 HcfObjDestroy(cipher); 332 } 333 }