From be9191179cf72d31458457025928146c11598d10 Mon Sep 17 00:00:00 2001 From: lichaochen_huawei Date: Thu, 28 Aug 2025 15:35:35 +0800 Subject: [PATCH] =?UTF-8?q?=E7=AE=97=E6=B3=95=E5=BA=93=E5=A2=9E=E5=8A=A0AE?= =?UTF-8?q?S-WRAP=E7=AE=97=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lichaochen_huawei --- common/inc/params_parser.h | 4 + common/src/params_parser.c | 4 + frameworks/crypto_operation/cipher.c | 6 + .../common/inc/openssl_adapter.h | 3 + .../common/src/openssl_adapter.c | 15 + .../cipher/src/cipher_aes_openssl.c | 35 ++ test/unittest/BUILD.gn | 1 + .../crypto_aes_wrap_cipher_test.cpp | 450 ++++++++++++++++++ test/unittest/src/openssl_adapter_mock.c | 24 + 9 files changed, 542 insertions(+) create mode 100644 test/unittest/src/aes_cipher/crypto_aes_wrap_cipher_test.cpp diff --git a/common/inc/params_parser.h b/common/inc/params_parser.h index d51625a..9dc094a 100644 --- a/common/inc/params_parser.h +++ b/common/inc/params_parser.h @@ -60,6 +60,9 @@ typedef enum { HCF_ALG_AES_128, HCF_ALG_AES_192, HCF_ALG_AES_256, + HCF_ALG_AES_WRAP128, + HCF_ALG_AES_WRAP192, + HCF_ALG_AES_WRAP256, HCF_ALG_SM4_128, HCF_ALG_DES_64, HCF_ALG_3DES_192, @@ -76,6 +79,7 @@ typedef enum { HCF_ALG_MODE_CFB128, HCF_ALG_MODE_CCM, HCF_ALG_MODE_GCM, + HCF_ALG_MODE_WRAP, HCF_ALG_NOPADDING, HCF_ALG_PADDING_PKCS5, diff --git a/common/src/params_parser.c b/common/src/params_parser.c index 07da926..aeee46d 100644 --- a/common/src/params_parser.c +++ b/common/src/params_parser.c @@ -30,6 +30,9 @@ static const HcfParaConfig PARAM_CONFIG[] = { {"AES128", HCF_ALG_KEY_TYPE, HCF_ALG_AES_128}, {"AES192", HCF_ALG_KEY_TYPE, HCF_ALG_AES_192}, {"AES256", HCF_ALG_KEY_TYPE, HCF_ALG_AES_256}, + {"AES-128-WRAP", HCF_ALG_KEY_TYPE, HCF_ALG_AES_WRAP128}, + {"AES-192-WRAP", HCF_ALG_KEY_TYPE, HCF_ALG_AES_WRAP192}, + {"AES-256-WRAP", HCF_ALG_KEY_TYPE, HCF_ALG_AES_WRAP256}, {"SM4_128", HCF_ALG_KEY_TYPE, HCF_ALG_SM4_128}, {"3DES192", HCF_ALG_KEY_TYPE, HCF_ALG_3DES_192}, {"DES64", HCF_ALG_KEY_TYPE, HCF_ALG_DES_64}, @@ -45,6 +48,7 @@ static const HcfParaConfig PARAM_CONFIG[] = { {"CFB128", HCF_ALG_MODE, HCF_ALG_MODE_CFB128}, {"CCM", HCF_ALG_MODE, HCF_ALG_MODE_CCM}, {"GCM", HCF_ALG_MODE, HCF_ALG_MODE_GCM}, + {"WRAP", HCF_ALG_MODE, HCF_ALG_MODE_WRAP}, {"NoPadding", HCF_ALG_PADDING_TYPE, HCF_ALG_NOPADDING}, {"PKCS5", HCF_ALG_PADDING_TYPE, HCF_ALG_PADDING_PKCS5}, diff --git a/frameworks/crypto_operation/cipher.c b/frameworks/crypto_operation/cipher.c index 9e7e063..f2a06f0 100644 --- a/frameworks/crypto_operation/cipher.c +++ b/frameworks/crypto_operation/cipher.c @@ -96,6 +96,12 @@ static void SetKeyLength(HcfAlgParaValue value, void *cipher) case HCF_ALG_AES_256: cipherAttr->algo = HCF_ALG_AES; break; + case HCF_ALG_AES_WRAP128: + case HCF_ALG_AES_WRAP192: + case HCF_ALG_AES_WRAP256: + cipherAttr->algo = HCF_ALG_AES; + cipherAttr->mode = HCF_ALG_MODE_WRAP; + break; case HCF_ALG_SM4_128: cipherAttr->algo = HCF_ALG_SM4; break; diff --git a/plugin/openssl_plugin/common/inc/openssl_adapter.h b/plugin/openssl_plugin/common/inc/openssl_adapter.h index f830458..17fde2e 100644 --- a/plugin/openssl_plugin/common/inc/openssl_adapter.h +++ b/plugin/openssl_plugin/common/inc/openssl_adapter.h @@ -290,6 +290,9 @@ const EVP_CIPHER *OpensslEvpAes256Ccm(void); const EVP_CIPHER *OpensslEvpAes128Gcm(void); const EVP_CIPHER *OpensslEvpAes192Gcm(void); const EVP_CIPHER *OpensslEvpAes256Gcm(void); +const EVP_CIPHER *OpensslEvpAes128Wrap(void); +const EVP_CIPHER *OpensslEvpAes192Wrap(void); +const EVP_CIPHER *OpensslEvpAes256Wrap(void); const EVP_CIPHER *OpensslEvpSm4Ecb(void); const EVP_CIPHER *OpensslEvpSm4Cbc(void); const EVP_CIPHER *OpensslEvpSm4Cfb(void); diff --git a/plugin/openssl_plugin/common/src/openssl_adapter.c b/plugin/openssl_plugin/common/src/openssl_adapter.c index f4ec918..29e7bf3 100644 --- a/plugin/openssl_plugin/common/src/openssl_adapter.c +++ b/plugin/openssl_plugin/common/src/openssl_adapter.c @@ -1129,6 +1129,21 @@ const EVP_CIPHER *OpensslEvpAes256Gcm(void) return EVP_aes_256_gcm(); } +const EVP_CIPHER *OpensslEvpAes128Wrap(void) +{ + return EVP_aes_128_wrap(); +} + +const EVP_CIPHER *OpensslEvpAes192Wrap(void) +{ + return EVP_aes_192_wrap(); +} + +const EVP_CIPHER *OpensslEvpAes256Wrap(void) +{ + return EVP_aes_256_wrap(); +} + const EVP_CIPHER *OpensslEvpSm4Ecb(void) { return EVP_sm4_ecb(); diff --git a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c index 462c45e..3236951 100644 --- a/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c +++ b/plugin/openssl_plugin/crypto_operation/cipher/src/cipher_aes_openssl.c @@ -31,6 +31,7 @@ #define CCM_IV_MIN_LEN 7 #define CCM_IV_MAX_LEN 13 #define CBC_CTR_OFB_CFB_IV_LEN 16 +#define AES_WRAP_IV_LEN 8 #define AES_BLOCK_SIZE 16 #define GCM_TAG_SIZE 16 #define CCM_TAG_SIZE 12 @@ -160,6 +161,17 @@ static const EVP_CIPHER *CipherGcmType(SymKeyImpl *symKey) } } +static const EVP_CIPHER *CipherWrapType(SymKeyImpl *symKey) +{ + if (symKey->keyMaterial.len == AES_SIZE_192) { + return OpensslEvpAes192Wrap(); + } else if (symKey->keyMaterial.len == AES_SIZE_256) { + return OpensslEvpAes256Wrap(); + } else { + return OpensslEvpAes128Wrap(); + } +} + static const EVP_CIPHER *DefaultCiherType(SymKeyImpl *symKey) { return CipherEcbType(symKey); @@ -188,6 +200,8 @@ static const EVP_CIPHER *GetCipherType(HcfCipherAesGeneratorSpiOpensslImpl *impl return CipherCcmType(symKey); case HCF_ALG_MODE_GCM: return CipherGcmType(symKey); + case HCF_ALG_MODE_WRAP: + return CipherWrapType(symKey); default: break; } @@ -245,6 +259,19 @@ static HcfResult IsIvParamsValid(HcfIvParamsSpec *params) return HCF_SUCCESS; } +static HcfResult IsAesWrapIvParamsValid(HcfIvParamsSpec *params) +{ + if (params == NULL) { + LOGE("params is null!"); + return HCF_INVALID_PARAMS; + } + if ((params->iv.data == NULL) || (params->iv.len != AES_WRAP_IV_LEN)) { + LOGE("iv is invalid!"); + return HCF_INVALID_PARAMS; + } + return HCF_SUCCESS; +} + static HcfResult InitAadAndTagFromGcmParams(enum HcfCryptoMode opMode, HcfGcmParamsSpec *params, CipherData *data) { if (!IsGcmParamsValid(params)) { @@ -343,6 +370,9 @@ static HcfResult InitCipherData(HcfCipherGeneratorSpi *self, enum HcfCryptoMode case HCF_ALG_MODE_CFB128: ret = IsIvParamsValid((HcfIvParamsSpec *)params); break; + case HCF_ALG_MODE_WRAP: + ret = IsAesWrapIvParamsValid((HcfIvParamsSpec *)params); + break; case HCF_ALG_MODE_CCM: ret = InitAadAndTagFromCcmParams(opMode, (HcfCcmParamsSpec *)params, *cipherData); break; @@ -514,6 +544,11 @@ static HcfResult EngineUpdate(HcfCipherGeneratorSpi *self, HcfBlob *input, HcfBl } HcfCipherAesGeneratorSpiOpensslImpl *cipherImpl = (HcfCipherAesGeneratorSpiOpensslImpl *)self; + if (cipherImpl->attr.mode == HCF_ALG_MODE_WRAP) { + LOGE("Openssl don't support update in wrap mode!"); + return HCF_NOT_SUPPORT; + } + CipherData *data = cipherImpl->cipherData; if (data == NULL) { LOGE("cipherData is null!"); diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index dc9bfb0..2388e56 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -42,6 +42,7 @@ ohos_unittest("crypto_framework_test") { "src/aes_cipher/crypto_aes_ecb_cipher_test.cpp", "src/aes_cipher/crypto_aes_gcm_cipher_test.cpp", "src/aes_cipher/crypto_aes_ofb_cipher_test.cpp", + "src/aes_cipher/crypto_aes_wrap_cipher_test.cpp", "src/crypto_3des_cipher_test.cpp", "src/crypto_asy_key_convert_pem_test.cpp", "src/crypto_asy_key_generator_cov_test.cpp", diff --git a/test/unittest/src/aes_cipher/crypto_aes_wrap_cipher_test.cpp b/test/unittest/src/aes_cipher/crypto_aes_wrap_cipher_test.cpp new file mode 100644 index 0000000..6b083c9 --- /dev/null +++ b/test/unittest/src/aes_cipher/crypto_aes_wrap_cipher_test.cpp @@ -0,0 +1,450 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include "securec.h" + +#include "aes_common.h" +#include "aes_openssl.h" +#include "blob.h" +#include "cipher.h" +#include "detailed_iv_params.h" +#include "log.h" +#include "memory.h" +#include "sym_common_defines.h" +#include "sym_key_generator.h" + +using namespace std; +using namespace testing::ext; + +namespace { +class CryptoAesWrapCipherTest : public testing::Test { +public: + static void SetUpTestCase() {}; + static void TearDownTestCase() {}; + void SetUp() {}; + void TearDown() {}; +}; + +static int32_t AesWrapEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, + HcfBlob *keyBlob, HcfBlob *output) +{ + int32_t ret = cipher->init(cipher, ENCRYPT_MODE, reinterpret_cast(key), params); + if (ret != 0) { + LOGE("init failed! %{public}d", ret); + return ret; + } + + ret = cipher->doFinal(cipher, keyBlob, output); + if (ret != 0) { + LOGE("doFinal failed!"); + return ret; + } + + PrintfHex("ciphertext", output->data, output->len); + return 0; +} + +static int32_t AesWrapDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params, + HcfBlob *input, HcfBlob *output) +{ + int32_t ret = cipher->init(cipher, DECRYPT_MODE, reinterpret_cast(key), params); + if (ret != 0) { + LOGE("init failed! %{public}d", ret); + return ret; + } + + ret = cipher->doFinal(cipher, input, output); + if (ret != 0) { + LOGE("doFinal failed!"); + return ret; + } + + PrintfHex("plaintext", output->data, output->len); + return 0; +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest001, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[8] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + HcfBlob plainOutput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 8; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_EQ(ret, 0); + + ret = AesWrapDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &cipherInput, &plainOutput); + ASSERT_EQ(ret, 0); + + ASSERT_EQ(plainOutput.len, keyBlob.len); + ASSERT_EQ(memcmp(plainOutput.data, keyBlob.data, keyBlob.len), 0); + + HcfBlobDataFree(&keyBlob); + HcfBlobDataFree(&cipherInput); + HcfBlobDataFree(&plainOutput); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest002, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[8] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + HcfBlob plainOutput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 8; + + ret = HcfSymKeyGeneratorCreate("AES192", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-192-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_EQ(ret, 0); + + ret = AesWrapDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &cipherInput, &plainOutput); + ASSERT_EQ(ret, 0); + + ASSERT_EQ(plainOutput.len, keyBlob.len); + ASSERT_EQ(memcmp(plainOutput.data, keyBlob.data, keyBlob.len), 0); + + HcfBlobDataFree(&keyBlob); + HcfBlobDataFree(&cipherInput); + HcfBlobDataFree(&plainOutput); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest003, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[8] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + HcfBlob plainOutput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 8; + + ret = HcfSymKeyGeneratorCreate("AES256", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-256-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_EQ(ret, 0); + + ret = AesWrapDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &cipherInput, &plainOutput); + ASSERT_EQ(ret, 0); + + ASSERT_EQ(plainOutput.len, keyBlob.len); + ASSERT_EQ(memcmp(plainOutput.data, keyBlob.data, keyBlob.len), 0); + + HcfBlobDataFree(&keyBlob); + HcfBlobDataFree(&cipherInput); + HcfBlobDataFree(&plainOutput); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest004, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + HcfBlob plainOutput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 8; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_EQ(ret, 0); + + ret = AesWrapDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &cipherInput, &plainOutput); + ASSERT_EQ(ret, 0); + + ASSERT_EQ(plainOutput.len, keyBlob.len); + ASSERT_EQ(memcmp(plainOutput.data, keyBlob.data, keyBlob.len), 0); + + HcfBlobDataFree(&keyBlob); + HcfBlobDataFree(&cipherInput); + HcfBlobDataFree(&plainOutput); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest005, TestSize.Level0) +{ + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + + int ret = GenerateSymKey("AES128", &key); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr); + ASSERT_NE(ret, 0); + + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest006, TestSize.Level0) +{ + HcfCipher *cipher = nullptr; + + int ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = cipher->init(cipher, ENCRYPT_MODE, nullptr, nullptr); + ASSERT_NE(ret, 0); + + HcfObjDestroy((HcfObjectBase *)cipher); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest007, TestSize.Level0) +{ + HcfSymKeyGenerator *generator = nullptr; + HcfSymKey *key = nullptr; + HcfCipher *cipher = nullptr; + + int ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = cipher->init(reinterpret_cast(generator), ENCRYPT_MODE, &(key->key), nullptr); + ASSERT_NE(ret, 0); + + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest008, TestSize.Level0) +{ + HcfCipher *cipher = nullptr; + + int ret = HcfCipherCreate("INVALID-ALGORITHM", &cipher); + ASSERT_NE(ret, 0); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest009, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[16] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 16; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-256-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_NE(ret, 0); + + HcfBlobDataFree(&keyBlob); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest010, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[32] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 32; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_NE(ret, 0); + + HcfBlobDataFree(&keyBlob); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest011, TestSize.Level0) +{ + int ret = 0; + + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {}; + HcfBlob cipherInput = {}; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = key->key.getEncoded(reinterpret_cast(key), &keyBlob); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, nullptr, &keyBlob, &cipherInput); + ASSERT_NE(ret, 0); + + HcfBlobDataFree(&keyBlob); + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} + +HWTEST_F(CryptoAesWrapCipherTest, CryptoAesWrapCipherTest012, TestSize.Level0) +{ + int ret = 0; + uint8_t iv[16] = {0}; + + HcfIvParamsSpec ivSpec = {}; + HcfSymKeyGenerator *generator = nullptr; + HcfCipher *cipher = nullptr; + HcfSymKey *key = nullptr; + HcfBlob keyBlob = {.data = nullptr, .len = 0}; + HcfBlob cipherInput = {}; + ivSpec.iv.data = iv; + ivSpec.iv.len = 16; + + ret = HcfSymKeyGeneratorCreate("AES128", &generator); + ASSERT_EQ(ret, 0); + + ret = generator->generateSymKey(generator, &key); + ASSERT_EQ(ret, 0); + + ret = HcfCipherCreate("AES-128-WRAP", &cipher); + ASSERT_EQ(ret, 0); + + ret = AesWrapEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, &keyBlob, &cipherInput); + ASSERT_NE(ret, 0); + + HcfObjDestroy((HcfObjectBase *)key); + HcfObjDestroy((HcfObjectBase *)cipher); + HcfObjDestroy((HcfObjectBase *)generator); +} +} \ No newline at end of file diff --git a/test/unittest/src/openssl_adapter_mock.c b/test/unittest/src/openssl_adapter_mock.c index 3d18180..074513c 100644 --- a/test/unittest/src/openssl_adapter_mock.c +++ b/test/unittest/src/openssl_adapter_mock.c @@ -1605,6 +1605,30 @@ const EVP_CIPHER *OpensslEvpAes256Gcm(void) return EVP_aes_256_gcm(); } +const EVP_CIPHER *OpensslEvpAes128Wrap(void) +{ + if (IsNeedMock()) { + return NULL; + } + return EVP_aes_128_wrap(); +} + +const EVP_CIPHER *OpensslEvpAes192Wrap(void) +{ + if (IsNeedMock()) { + return NULL; + } + return EVP_aes_192_wrap(); +} + +const EVP_CIPHER *OpensslEvpAes256Wrap(void) +{ + if (IsNeedMock()) { + return NULL; + } + return EVP_aes_256_wrap(); +} + EVP_CIPHER_CTX *OpensslEvpCipherCtxNew(void) { if (IsNeedMock()) { -- Gitee