diff --git a/.gitattributes b/.gitattributes old mode 100644 new mode 100755 diff --git a/BUILD.gn b/BUILD.gn index f0e24bb8cbef8c373a04d6d7ab7b4b8a7f4e3ee1..d1991965809e46cd3fb80f62a5d11e9fd2de0e39 100755 --- a/BUILD.gn +++ b/BUILD.gn @@ -11,10 +11,10 @@ # See the License for the specific language governing permissions and # limitations under the License. - group("huks_sdk_test") { testonly = true deps = [ + "//base/security/huks/frameworks/huks_standard/main/crypto_engine/test:crypto_engine_test", "//base/security/huks/interfaces/innerkits/huks_standard/test:hukssdk_test", ] } diff --git a/frameworks/huks_standard/main/common/include/hks_base_check.h b/frameworks/huks_standard/main/common/include/hks_base_check.h index 106db9d7ee0733a1b4522e71b0218bc1d61af040..d048dad254fd7d9c32c91d48b04813445c2c2751 100644 --- a/frameworks/huks_standard/main/common/include/hks_base_check.h +++ b/frameworks/huks_standard/main/common/include/hks_base_check.h @@ -80,7 +80,9 @@ int32_t HksCheckFixedParams(uint32_t alg, enum CheckKeyType checkType, const str int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inputParams); -int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, const struct HksBlob *key, const struct HksBlob *signature); +int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params); + +int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature); int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams); diff --git a/frameworks/huks_standard/main/common/include/hks_check_paramset.h b/frameworks/huks_standard/main/common/include/hks_check_paramset.h index d708f03405482e350d3e1708e103e7405d957920..cd6804972e1d9926ddd618f7ce8881eaf6b35754 100755 --- a/frameworks/huks_standard/main/common/include/hks_check_paramset.h +++ b/frameworks/huks_standard/main/common/include/hks_check_paramset.h @@ -38,7 +38,10 @@ int32_t HksCoreCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, cons int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck); -int32_t HksLocalCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, +int32_t HksLocalCheckSignVerifyParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature); + +int32_t HksLocalCheckCipherParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, const struct HksBlob *inData, const struct HksBlob *outData); int32_t HksCoreCheckDeriveKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *mainKey, diff --git a/frameworks/huks_standard/main/common/include/hks_common_check.h b/frameworks/huks_standard/main/common/include/hks_common_check.h index 44f16ba513c1c4d833c06a30d8de47078dc1a7a1..37c0b1e338d9557000888b956d4e2a46657c23ca 100644 --- a/frameworks/huks_standard/main/common/include/hks_common_check.h +++ b/frameworks/huks_standard/main/common/include/hks_common_check.h @@ -19,6 +19,9 @@ #include "hks_param.h" #include "hks_type_inner.h" +#define HKS_DIGEST_MD5_LEN 16 +#define HKS_DIGEST_SHA1_LEN 20 +#define HKS_DIGEST_SHA224_LEN 28 #define HKS_DIGEST_SHA256_LEN 32 #define HKS_DIGEST_SHA384_LEN 48 #define HKS_DIGEST_SHA512_LEN 64 diff --git a/frameworks/huks_standard/main/common/include/hks_config.h b/frameworks/huks_standard/main/common/include/hks_config.h index d1e94a4378300964394c0fa230d8f5b0d118819c..a6aaadec418a43f965edc008172313b6fc12c4ba 100644 --- a/frameworks/huks_standard/main/common/include/hks_config.h +++ b/frameworks/huks_standard/main/common/include/hks_config.h @@ -18,12 +18,17 @@ #define HKS_SUPPORT_POSIX +#define HKS_SUPPORT_THREAD + /* AES */ #define HKS_SUPPORT_AES_C #define HKS_SUPPORT_AES_GENERATE_KEY #define HKS_SUPPORT_AES_CBC_NOPADDING #define HKS_SUPPORT_AES_CBC_PKCS7 #define HKS_SUPPORT_AES_GCM +#define HKS_SUPPORT_AES_CTR_NOPADDING +#define HKS_SUPPORT_AES_ECB_NOPADDING +#define HKS_SUPPORT_AES_ECB_PKCS7PADDING /* BN */ #define HKS_SUPPORT_BN_C @@ -32,8 +37,16 @@ #define HKS_SUPPORT_ECC_C #define HKS_SUPPORT_ECC_GENERATE_KEY #define HKS_SUPPORT_ECC_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDH_C +#define HKS_SUPPORT_ECDH_GENERATE_KEY +#define HKS_SUPPORT_ECDH_AGREE_KEY +#define HKS_SUPPORT_ECDH_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDSA_C +#define HKS_SUPPORT_ECDSA_GENERATE_KEY +#define HKS_SUPPORT_ECDSA_SIGN_VERIFY +#define HKS_SUPPORT_EDDSA_GET_PUBLIC_KEY /* ED25519 */ #define HKS_SUPPORT_ED25519_C @@ -43,9 +56,21 @@ /* HASH */ #define HKS_SUPPORT_HASH_C +#define HKS_SUPPORT_HASH_SHA1 +#define HKS_SUPPORT_HASH_SHA224 +#define HKS_SUPPORT_HASH_SHA256 +#define HKS_SUPPORT_HASH_SHA384 +#define HKS_SUPPORT_HASH_SHA512 +#define HKS_SUPPORT_HASH_MD5 /* HMAC */ #define HKS_SUPPORT_HMAC_C +#define HKS_SUPPORT_HMAC_GENERATE_KEY +#define HKS_SUPPORT_HMAC_SHA1 +#define HKS_SUPPORT_HMAC_SHA224 +#define HKS_SUPPORT_HMAC_SHA256 +#define HKS_SUPPORT_HMAC_SHA384 +#define HKS_SUPPORT_HMAC_SHA512 /* KDF */ #define HKS_SUPPORT_KDF_C @@ -58,6 +83,27 @@ #define HKS_SUPPORT_RSA_CRYPT #define HKS_SUPPORT_RSA_SIGN_VERIFY #define HKS_SUPPORT_RSA_GET_PUBLIC_KEY +#define HKS_SUPPORT_RSA_ECB_NOPADDING +#define HKS_SUPPORT_RSA_ECB_PKCS1PADDING +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA1MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA224MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA256MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA384MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA512MGF1 +#define HKS_SUPPORT_RSA_ECB_OEAPPADDING +#define HKS_SUPPORT_RSA_PSS + +/* DH */ +#define HKS_SUPPORT_DH_C +#define HKS_SUPPORT_DH_GENERATE_KEY +#define HKS_SUPPORT_DH_AGREE_KEY +#define HKS_SUPPORT_DH_GET_PUBLIC_KEY + +/* DSA */ +#define HKS_SUPPORT_DSA_C +#define HKS_SUPPORT_DSA_GENERATE_KEY +#define HKS_SUPPORT_DSA_SIGN_VERIFY +#define HKS_SUPPORT_DSA_GET_PUBLIC_KEY /* X25519 */ #define HKS_SUPPORT_X25519_C @@ -67,30 +113,33 @@ #define HKS_SUPPORT_ED25519_TO_X25519 -#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ - defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_RSA_GENERATE_KEY) || \ - defined(HKS_SUPPORT_X25519_GENERATE_KEY) +#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_DH_GENERATE_KEY) || \ + defined(HKS_SUPPORT_DSA_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ECDH_GENERATE_KEY) || defined(HKS_SUPPORT_ECDSA_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_HMAC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_RSA_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) #define HKS_SUPPORT_API_GENERATE_KEY #define HKS_SUPPORT_API_DELETE_KEY #define HKS_SUPPORT_API_GET_KEY_PARAM_SET #define HKS_SUPPORT_API_KEY_EXIST #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) || \ - defined(HKS_SUPPORT_AES_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_IMPORT #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_EXPORT #endif #define HKS_SUPPORT_API_GENERATE_RANDOM -#if defined(HKS_SUPPORT_ECDSA_C) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ - defined(HKS_SUPPORT_RSA_SIGN_VERIFY) +#if defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ + defined(HKS_SUPPORT_RSA_SIGN_VERIFY) || defined(HKS_SUPPORT_DSA_SIGN_VERIFY) #define HKS_SUPPORT_API_SIGN_VERIFY #endif @@ -98,7 +147,7 @@ #define HKS_SUPPORT_API_CIPHER #endif -#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_C) +#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_AGREE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) #define HKS_SUPPORT_API_AGREE_KEY #endif diff --git a/frameworks/huks_standard/main/common/include/hks_config_base.h b/frameworks/huks_standard/main/common/include/hks_config_base.h index 301f53333c60cf5d1586f04d40af47696f91ec1c..5899baa526e9879d673771b482efae9651160636 100644 --- a/frameworks/huks_standard/main/common/include/hks_config_base.h +++ b/frameworks/huks_standard/main/common/include/hks_config_base.h @@ -27,6 +27,9 @@ #define HKS_SUPPORT_AES_CBC_PKCS7 #define HKS_SUPPORT_AES_GCM #define HKS_SUPPORT_AES_CCM +#define HKS_SUPPORT_AES_CTR_NOPADDING +#define HKS_SUPPORT_AES_ECB_NOPADDING +#define HKS_SUPPORT_AES_ECB_PKCS7PADDING /* BN */ #define HKS_SUPPORT_BN_C @@ -35,8 +38,16 @@ #define HKS_SUPPORT_ECC_C #define HKS_SUPPORT_ECC_GENERATE_KEY #define HKS_SUPPORT_ECC_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDH_C +#define HKS_SUPPORT_ECDH_GENERATE_KEY +#define HKS_SUPPORT_ECDH_AGREE_KEY +#define HKS_SUPPORT_ECDH_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDSA_C +#define HKS_SUPPORT_ECDSA_GENERATE_KEY +#define HKS_SUPPORT_ECDSA_SIGN_VERIFY +#define HKS_SUPPORT_EDDSA_GET_PUBLIC_KEY /* ED25519 */ #define HKS_SUPPORT_ED25519_C @@ -46,9 +57,21 @@ /* HASH */ #define HKS_SUPPORT_HASH_C +#define HKS_SUPPORT_HASH_SHA1 +#define HKS_SUPPORT_HASH_SHA224 +#define HKS_SUPPORT_HASH_SHA256 +#define HKS_SUPPORT_HASH_SHA384 +#define HKS_SUPPORT_HASH_SHA512 +#define HKS_SUPPORT_HASH_MD5 /* HMAC */ #define HKS_SUPPORT_HMAC_C +#define HKS_SUPPORT_HMAC_GENERATE_KEY +#define HKS_SUPPORT_HMAC_SHA1 +#define HKS_SUPPORT_HMAC_SHA224 +#define HKS_SUPPORT_HMAC_SHA256 +#define HKS_SUPPORT_HMAC_SHA384 +#define HKS_SUPPORT_HMAC_SHA512 /* KDF */ #define HKS_SUPPORT_KDF_C @@ -61,6 +84,27 @@ #define HKS_SUPPORT_RSA_CRYPT #define HKS_SUPPORT_RSA_SIGN_VERIFY #define HKS_SUPPORT_RSA_GET_PUBLIC_KEY +#define HKS_SUPPORT_RSA_ECB_NOPADDING +#define HKS_SUPPORT_RSA_ECB_PKCS1PADDING +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA1MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA224MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA256MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA384MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA512MGF1 +#define HKS_SUPPORT_RSA_ECB_OEAPPADDING +#define HKS_SUPPORT_RSA_PSS + +/* DH */ +#define HKS_SUPPORT_DH_C +#define HKS_SUPPORT_DH_GENERATE_KEY +#define HKS_SUPPORT_DH_AGREE_KEY +#define HKS_SUPPORT_DH_GET_PUBLIC_KEY + +/* DSA */ +#define HKS_SUPPORT_DSA_C +#define HKS_SUPPORT_DSA_GENERATE_KEY +#define HKS_SUPPORT_DSA_SIGN_VERIFY +#define HKS_SUPPORT_DSA_GET_PUBLIC_KEY /* X25519 */ #define HKS_SUPPORT_X25519_C @@ -70,30 +114,33 @@ #define HKS_SUPPORT_ED25519_TO_X25519 -#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ - defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_RSA_GENERATE_KEY) || \ - defined(HKS_SUPPORT_X25519_GENERATE_KEY) +#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_DH_GENERATE_KEY) || \ + defined(HKS_SUPPORT_DSA_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ECDH_GENERATE_KEY) || defined(HKS_SUPPORT_ECDSA_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_HMAC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_RSA_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) #define HKS_SUPPORT_API_GENERATE_KEY #define HKS_SUPPORT_API_DELETE_KEY #define HKS_SUPPORT_API_GET_KEY_PARAM_SET #define HKS_SUPPORT_API_KEY_EXIST #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) || \ - defined(HKS_SUPPORT_AES_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_IMPORT #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_EXPORT #endif #define HKS_SUPPORT_API_GENERATE_RANDOM -#if defined(HKS_SUPPORT_ECDSA_C) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ - defined(HKS_SUPPORT_RSA_SIGN_VERIFY) +#if defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ + defined(HKS_SUPPORT_RSA_SIGN_VERIFY) || defined(HKS_SUPPORT_DSA_SIGN_VERIFY) #define HKS_SUPPORT_API_SIGN_VERIFY #endif @@ -101,7 +148,7 @@ #define HKS_SUPPORT_API_CIPHER #endif -#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_C) +#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_AGREE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) #define HKS_SUPPORT_API_AGREE_KEY #endif diff --git a/frameworks/huks_standard/main/common/include/hks_crypto_hal.h b/frameworks/huks_standard/main/common/include/hks_crypto_hal.h index 9b83e485b8b11648a4ebfafd33927e866930c266..a6a3a21741cb044cdd9ed605d658d8d8328cc977 100755 --- a/frameworks/huks_standard/main/common/include/hks_crypto_hal.h +++ b/frameworks/huks_standard/main/common/include/hks_crypto_hal.h @@ -88,6 +88,24 @@ struct KeyMaterialEcc { uint32_t zSize; }; +struct KeyMaterialDsa { + enum HksKeyAlg keyAlg; + uint32_t keySize; + uint32_t xSize; + uint32_t ySize; + uint32_t pSize; + uint32_t qSize; + uint32_t gSize; +}; + +struct KeyMaterialDh { + enum HksKeyAlg keyAlg; + uint32_t keySize; + uint32_t pubKeySize; + uint32_t priKeySize; + uint32_t reserved; +}; + struct KeyMaterial25519 { enum HksKeyAlg keyAlg; uint32_t keySize; diff --git a/frameworks/huks_standard/main/common/include/hks_type.h b/frameworks/huks_standard/main/common/include/hks_type.h index dfb1d58a1a0d0d744df7f975db1464ece55db601..dc081e348fdb5d3c7511f85518514cdcd3b8886e 100755 --- a/frameworks/huks_standard/main/common/include/hks_type.h +++ b/frameworks/huks_standard/main/common/include/hks_type.h @@ -51,7 +51,7 @@ extern "C" { #define HKS_MAX_KEY_ALIAS_LEN 64 #define HKS_MAX_PROCESS_NAME_LEN 50 #define HKS_MAX_RANDOM_LEN 1024 -#define HKS_KEY_BYTES(keySize) ((keySize) / HKS_BITS_PER_BYTE) +#define HKS_KEY_BYTES(keySize) (((keySize) + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE) #define HKS_SIGNATURE_MIN_SIZE 64 #define HKS_ARRAY_SIZE(arr) ((sizeof(arr)) / (sizeof((arr)[0]))) #define MAX_OUT_BLOB_SIZE (5 * 1024 * 1024) @@ -90,6 +90,7 @@ enum HksKeyPurpose { HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ }; enum HksKeyDigest { @@ -121,11 +122,14 @@ enum HksCipherMode { }; enum HksKeySize { + HKS_RSA_KEY_SIZE_512 = 512, + HKS_RSA_KEY_SIZE_768 = 768, HKS_RSA_KEY_SIZE_1024 = 1024, HKS_RSA_KEY_SIZE_2048 = 2048, HKS_RSA_KEY_SIZE_3072 = 3072, HKS_RSA_KEY_SIZE_4096 = 4096, + HKS_ECC_KEY_SIZE_224 = 224, HKS_ECC_KEY_SIZE_256 = 256, HKS_ECC_KEY_SIZE_384 = 384, HKS_ECC_KEY_SIZE_521 = 521, @@ -136,11 +140,16 @@ enum HksKeySize { HKS_AES_KEY_SIZE_512 = 512, HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, }; enum HksKeyAlg { HKS_ALG_RSA = 1, HKS_ALG_ECC = 2, + HKS_ALG_DSA = 3, HKS_ALG_AES = 20, HKS_ALG_HMAC = 50, @@ -150,6 +159,7 @@ enum HksKeyAlg { HKS_ALG_ECDH = 100, HKS_ALG_X25519 = 101, HKS_ALG_ED25519 = 102, + HKS_ALG_DH = 103, }; enum HksKeyGenerateType { @@ -405,6 +415,11 @@ struct HksPubKeyInfo { uint32_t placeHolder; }; +struct HksKeyMaterialHeader { + enum HksKeyAlg keyAlg; + uint32_t keySize; +}; + #define HKS_DERIVE_DEFAULT_SALT_LEN 16 #define HKS_HMAC_DIGEST_SHA512_LEN 64 #define HKS_DEFAULT_RANDOM_LEN 16 diff --git a/frameworks/huks_standard/main/common/src/hks_base_check.c b/frameworks/huks_standard/main/common/src/hks_base_check.c index 3906e08086e5b55c3d0ed10694160dca9b4001ab..b26a0ca7bc893244697e72fdae8be6dc872cdca1 100755 --- a/frameworks/huks_standard/main/common/src/hks_base_check.c +++ b/frameworks/huks_standard/main/common/src/hks_base_check.c @@ -46,29 +46,43 @@ #ifdef HKS_SUPPORT_RSA_C static uint32_t g_rsaKeySize[] = { + HKS_RSA_KEY_SIZE_512, + HKS_RSA_KEY_SIZE_768, + HKS_RSA_KEY_SIZE_1024, HKS_RSA_KEY_SIZE_2048, - HKS_RSA_KEY_SIZE_3072 + HKS_RSA_KEY_SIZE_3072, + HKS_RSA_KEY_SIZE_4096 }; static uint32_t g_rsaPadding[] = { + HKS_PADDING_NONE, + HKS_PADDING_OAEP, HKS_PADDING_PSS, - HKS_PADDING_OAEP + HKS_PADDING_PKCS1_V1_5 }; static uint32_t g_rsaDigest[] = { + HKS_DIGEST_MD5, + HKS_DIGEST_NONE, + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, HKS_DIGEST_SHA256, HKS_DIGEST_SHA384, HKS_DIGEST_SHA512 }; static uint32_t g_rsaSignPadding[] = { HKS_PADDING_PSS, + HKS_PADDING_PKCS1_V1_5 }; static uint32_t g_rsaCipherPadding[] = { - HKS_PADDING_OAEP + HKS_PADDING_NONE, + HKS_PADDING_OAEP, + HKS_PADDING_PKCS1_V1_5 }; #endif #ifdef HKS_SUPPORT_AES_C static uint32_t g_aesKeySize[] = { HKS_AES_KEY_SIZE_128, + HKS_AES_KEY_SIZE_192, HKS_AES_KEY_SIZE_256 }; static uint32_t g_aesMacKeySize[] = { @@ -81,6 +95,8 @@ static uint32_t g_aesPadding[] = { static uint32_t g_aesMode[] = { HKS_MODE_CBC, HKS_MODE_CCM, + HKS_MODE_CTR, + HKS_MODE_ECB, HKS_MODE_GCM }; static uint32_t g_aesCbcPadding[] = { @@ -90,12 +106,30 @@ static uint32_t g_aesCbcPadding[] = { static uint32_t g_aesAeadPadding[] = { HKS_PADDING_NONE }; +static uint32_t g_aesCtrPadding[] = { + HKS_PADDING_NONE +}; +static uint32_t g_aesEcbPadding[] = { + HKS_PADDING_NONE, + HKS_PADDING_PKCS7 +}; #endif #ifdef HKS_SUPPORT_ECC_C static uint32_t g_eccKeySize[] = { + HKS_ECC_KEY_SIZE_224, HKS_ECC_KEY_SIZE_256, HKS_ECC_KEY_SIZE_384, + HKS_ECC_KEY_SIZE_521 +}; + +static uint32_t g_eccDigest[] = { + HKS_DIGEST_NONE, + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, + HKS_DIGEST_SHA256, + HKS_DIGEST_SHA384, + HKS_DIGEST_SHA512 }; #endif @@ -111,8 +145,10 @@ static uint32_t g_macDigest[] = { #ifdef HKS_SUPPORT_ECDH_C static uint32_t g_ecdhKeySize[] = { + HKS_ECC_KEY_SIZE_224, HKS_ECC_KEY_SIZE_256, HKS_ECC_KEY_SIZE_384, + HKS_ECC_KEY_SIZE_521 }; #endif @@ -121,11 +157,36 @@ static const uint32_t g_curve25519KeySize[] = { HKS_CURVE25519_KEY_SIZE_256, }; #endif +#ifdef HKS_SUPPORT_HMAC_C +static uint32_t g_hmacDigest[] = { + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, + HKS_DIGEST_SHA256, + HKS_DIGEST_SHA384, + HKS_DIGEST_SHA512 +}; +#endif +#ifdef HKS_SUPPORT_DSA_C +static uint32_t g_dsaDigest[] = { + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, + HKS_DIGEST_SHA256, + HKS_DIGEST_SHA384, + HKS_DIGEST_SHA512 +}; +#endif +#ifdef HKS_SUPPORT_DH_C +static uint32_t g_dhKeySize[] = { + HKS_DH_KEY_SIZE_2048, + HKS_DH_KEY_SIZE_3072, + HKS_DH_KEY_SIZE_4096 +}; +#endif #ifdef HKS_SUPPORT_RSA_C static const struct ParamsValuesChecker g_rsaParamSet[] = { { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { true, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } }, - { HKS_CHECK_TYPE_USE_KEY, { { false, 0 }, { true, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } } + { HKS_CHECK_TYPE_USE_KEY, { { true, 0 }, { true, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } } }; static const struct ExpectParamsValuesChecker g_expectRsaParams[] = { { HKS_CHECK_TYPE_GEN_KEY, { @@ -137,7 +198,7 @@ static const struct ExpectParamsValuesChecker g_expectRsaParams[] = { } }, { HKS_CHECK_TYPE_USE_KEY, { - { false, NULL, 0 }, + { true, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize) }, { true, g_rsaPadding, HKS_ARRAY_SIZE(g_rsaPadding) }, { false, NULL, 0 }, { true, g_rsaDigest, HKS_ARRAY_SIZE(g_rsaDigest) }, @@ -151,6 +212,7 @@ static const struct ExpectParamsValuesChecker g_expectRsaParams[] = { static const struct ParamsValuesChecker g_aesParamSet[] = { { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { true, 0 }, { true, 0 }, { false, 0 }, { true, 0 } } }, { HKS_CHECK_TYPE_USE_KEY, { { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 }, { true, 0 } } }, + { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0 }, { false, 0 }, { false, 0 }, { true, 0 }, { false, 0 } } }, { HKS_CHECK_TYPE_GEN_DERIVE_KEY, { { true, 0 }, { false, 0 }, { false, 0 }, { true, 0 }, { false, 0 } } } }; @@ -200,7 +262,7 @@ static const struct ExpectParamsValuesChecker g_expectEccParams[] = { { true, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize) }, { false, NULL, 0 }, { false, NULL, 0 }, - { true, g_digest, HKS_ARRAY_SIZE(g_digest) }, + { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) }, { false, NULL, 0 } } }, @@ -208,7 +270,7 @@ static const struct ExpectParamsValuesChecker g_expectEccParams[] = { { false, NULL, 0 }, { false, NULL, 0 }, { false, NULL, 0 }, - { true, g_digest, HKS_ARRAY_SIZE(g_digest) }, + { true, g_eccDigest, HKS_ARRAY_SIZE(g_eccDigest) }, { false, NULL, 0 } } } @@ -240,6 +302,179 @@ static const struct ExpectParamsValuesChecker g_expectCurve25519Params[] = { }; #endif +#ifdef HKS_SUPPORT_HMAC_C +static const struct ParamsValuesChecker g_hmacParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { false, 0 }, { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_GEN_MAC_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectHmacParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_GEN_MAC_KEY, { + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { true, g_hmacDigest, sizeof(g_hmacDigest) / sizeof(g_hmacDigest[0]) }, + { false, NULL, 0 } + } + } +}; +#endif + +#ifdef HKS_SUPPORT_DSA_C +static const struct ParamsValuesChecker g_dsaParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { false, 0 }, { false, 0 }, { true, 0 }, { true, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectDsaParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { true, g_dsaDigest, sizeof(g_dsaDigest) / sizeof(g_dsaDigest[0]) }, + { false, NULL, 0 } + } + } +}; +#endif + +#ifdef HKS_SUPPORT_DH_C +static const struct ParamsValuesChecker g_dhParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectDhParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + } +}; +#endif + +#ifdef HKS_SUPPORT_ECDH_C +static const struct ParamsValuesChecker g_ecdhParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectEcdhParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + } +}; +#endif + +static uint32_t INVALID_PURPOSE[][2] = { +#ifdef HKS_SUPPORT_RSA_C + { + HKS_ALG_RSA, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_ECC_C + { + HKS_ALG_ECC, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_AES_C + { + HKS_ALG_AES, + HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_ED25519_C + { + HKS_ALG_ED25519, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_X25519_C + { + HKS_ALG_X25519, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_HMAC_C + { + HKS_ALG_HMAC, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP | + HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_DSA_C + { + HKS_ALG_DSA, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_DH_C + { + HKS_ALG_DH, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, +#endif +#ifdef HKS_SUPPORT_ECDH_C + { + HKS_ALG_ECDH, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, +#endif +}; + #ifndef _CUT_AUTHENTICATE_ #ifndef _STORAGE_LITE_ static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize, @@ -301,52 +536,44 @@ static int32_t CheckPurposeUnique(uint32_t inputPurpose) uint32_t purposeDerive = inputPurpose & HKS_KEY_PURPOSE_DERIVE; uint32_t purposeWrap = inputPurpose & (HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP); uint32_t purposeMac = inputPurpose & HKS_KEY_PURPOSE_MAC; + uint32_t purposeAgree = inputPurpose & HKS_KEY_PURPOSE_AGREE; uint32_t purposeCount = (purposeCipher != 0) ? 1 : 0; purposeCount += (purposeSign != 0) ? 1 : 0; purposeCount += (purposeDerive != 0) ? 1 : 0; purposeCount += (purposeWrap != 0) ? 1 : 0; purposeCount += (purposeMac != 0) ? 1 : 0; + purposeCount += (purposeAgree != 0) ? 1 : 0; return (purposeCount == 1) ? HKS_SUCCESS : HKS_ERROR_INVALID_PURPOSE; } +static int32_t GetInvalidPurpose(uint32_t alg, uint32_t *inputPurpose) +{ + int32_t result = HKS_ERROR_INVALID_ALGORITHM; + if (sizeof(INVALID_PURPOSE) == 0) { + return result; + } + uint32_t count = sizeof(INVALID_PURPOSE) / sizeof(INVALID_PURPOSE[0]); + for (uint32_t i = 0; i < count; i++) { + if (alg == INVALID_PURPOSE[i][0]) { + result = HKS_SUCCESS; + *inputPurpose = INVALID_PURPOSE[i][1]; + break; + } + } + return result; +} + static int32_t CheckPurposeValid(uint32_t alg, uint32_t inputPurpose) { uint32_t invalidPurpose = 0; - switch (alg) { -#ifdef HKS_SUPPORT_RSA_C - case HKS_ALG_RSA: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP; - break; -#endif -#ifdef HKS_SUPPORT_ECC_C - case HKS_ALG_ECC: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_AES_C - case HKS_ALG_AES: - invalidPurpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY; - break; -#endif -#ifdef HKS_SUPPORT_ED25519_C - case HKS_ALG_ED25519: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_X25519_C - case HKS_ALG_X25519: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | - HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif - default: - return HKS_ERROR_INVALID_ALGORITHM; + + uint32_t result = GetInvalidPurpose(alg, &invalidPurpose); + if (result != HKS_SUCCESS) { + return result; } + if ((inputPurpose & invalidPurpose) != 0) { return HKS_ERROR_INVALID_PURPOSE; } @@ -407,7 +634,6 @@ static int32_t GetInputParams(const struct HksParamSet *paramSet, struct ParamsV return ret; } - static int32_t InitInputParams(enum CheckKeyType checkType, struct ParamsValues *inputParams, const struct ParamsValuesChecker *checkSet, uint32_t checkSetSize) { @@ -443,6 +669,22 @@ static int32_t InitInputParamsByAlg(uint32_t alg, enum CheckKeyType checkType, s case HKS_ALG_X25519: case HKS_ALG_ED25519: return InitInputParams(checkType, inputParams, g_curve25519ParamSet, HKS_ARRAY_SIZE(g_curve25519ParamSet)); +#endif +#ifdef HKS_SUPPORT_HMAC_C + case HKS_ALG_HMAC: + return InitInputParams(checkType, inputParams, g_hmacParamSet, HKS_ARRAY_SIZE(g_hmacParamSet)); +#endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: + return InitInputParams(checkType, inputParams, g_dsaParamSet, HKS_ARRAY_SIZE(g_dsaParamSet)); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return InitInputParams(checkType, inputParams, g_dhParamSet, HKS_ARRAY_SIZE(g_dhParamSet)); +#endif +#ifdef HKS_SUPPORT_ECDH_C + case HKS_ALG_ECDH: + return InitInputParams(checkType, inputParams, g_ecdhParamSet, HKS_ARRAY_SIZE(g_ecdhParamSet)); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -485,6 +727,22 @@ static int32_t GetExpectParams(uint32_t alg, enum CheckKeyType checkType, struct case HKS_ALG_ED25519: return InitExpectParams(checkType, expectValues, g_expectCurve25519Params, HKS_ARRAY_SIZE(g_expectCurve25519Params)); +#endif +#ifdef HKS_SUPPORT_HMAC_C + case HKS_ALG_HMAC: + return InitExpectParams(checkType, expectValues, g_expectHmacParams, HKS_ARRAY_SIZE(g_expectHmacParams)); +#endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: + return InitExpectParams(checkType, expectValues, g_expectDsaParams, HKS_ARRAY_SIZE(g_expectDsaParams)); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return InitExpectParams(checkType, expectValues, g_expectDhParams, HKS_ARRAY_SIZE(g_expectDhParams)); +#endif +#ifdef HKS_SUPPORT_ECDH_C + case HKS_ALG_ECDH: + return InitExpectParams(checkType, expectValues, g_expectEcdhParams, HKS_ARRAY_SIZE(g_expectEcdhParams)); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -557,6 +815,7 @@ static int32_t CheckRsaGenKeyPadding(const struct ParamsValues *inputParams) return HKS_SUCCESS; } +#ifdef HKS_SUPPORT_RSA_SIGN_VERIFY static int32_t CheckRsaSignature(uint32_t cmdId, uint32_t keySize, const struct HksBlob *signature) { /* @@ -582,7 +841,9 @@ static int32_t CheckRsaSignature(uint32_t cmdId, uint32_t keySize, const struct return HKS_SUCCESS; } +#endif +#ifdef HKS_SUPPORT_RSA_CRYPT static int32_t CheckRsaNoPadCipherData(uint32_t keySize, const struct HksBlob *inData, const struct HksBlob *outData) { @@ -604,6 +865,9 @@ static int32_t CheckRsaOaepCipherData(uint32_t cmdId, uint32_t keySize, uint32_t const struct HksBlob *inData, const struct HksBlob *outData) { uint32_t digestLen; + if (digest == HKS_DIGEST_NONE) { + digest = HKS_DIGEST_SHA1; + } int32_t ret = HksGetDigestLen(digest, &digestLen); if (ret != HKS_SUCCESS) { HKS_LOG_E("GetDigestLen failed, ret = %x", ret); @@ -614,7 +878,7 @@ static int32_t CheckRsaOaepCipherData(uint32_t cmdId, uint32_t keySize, uint32_t * encrypt: inSize no greater than keySize - 2*digestLen - 2, outSize no less than keySize (in: plain; out: cipher) * decrypt: inSize no greater than keySize, outSize no less than keySize - 2*digestLen - 2 (in: cipher; out: plain) */ - if (keySize <= (HKS_RSA_OAEP_DIGEST_NUM * digestLen - HKS_RSA_OAEP_DIGEST_NUM)) { + if (keySize <= (HKS_RSA_OAEP_DIGEST_NUM * digestLen + HKS_RSA_OAEP_DIGEST_NUM)) { return HKS_ERROR_INVALID_KEY_FILE; } uint32_t size = keySize - HKS_RSA_OAEP_DIGEST_NUM * digestLen - HKS_RSA_OAEP_DIGEST_NUM; @@ -661,6 +925,7 @@ static int32_t CheckRsaCipherData(uint32_t cmdId, const struct ParamsValues *inp return ret; } #endif +#endif #ifdef HKS_SUPPORT_AES_C static int32_t CheckAesPadding(uint32_t mode, uint32_t padding) @@ -669,6 +934,14 @@ static int32_t CheckAesPadding(uint32_t mode, uint32_t padding) return HksCheckValue(padding, g_aesCbcPadding, HKS_ARRAY_SIZE(g_aesCbcPadding)); } + if (mode == HKS_MODE_CTR) { + return HksCheckValue(padding, g_aesCtrPadding, HKS_ARRAY_SIZE(g_aesCbcPadding)); + } + + if (mode == HKS_MODE_ECB) { + return HksCheckValue(padding, g_aesEcbPadding, HKS_ARRAY_SIZE(g_aesCbcPadding)); + } + if ((mode == HKS_MODE_GCM) || (mode == HKS_MODE_CCM)) { return HksCheckValue(padding, g_aesAeadPadding, HKS_ARRAY_SIZE(g_aesAeadPadding)); } @@ -761,7 +1034,7 @@ static int32_t CheckAesCipherData(uint32_t cmdId, const struct ParamsValues *inp { uint32_t mode = inputParams->mode.value; - if (mode == HKS_MODE_CBC) { + if ((mode == HKS_MODE_CBC) || (mode == HKS_MODE_CTR) || (mode == HKS_MODE_ECB)) { uint32_t padding = inputParams->padding.value; return CheckAesCbcCipherData(cmdId, padding, inData, outData); } else if ((mode == HKS_MODE_GCM) || (mode == HKS_MODE_CCM)) { @@ -883,6 +1156,31 @@ int32_t HksCheckGenKeyPurpose(uint32_t alg, uint32_t inputPurpose) return CheckPurposeValid(alg, inputPurpose); } +static int32_t HksGetDsaKeySize(const struct HksBlob *key, uint32_t *keySize) + +{ + if (key->size < sizeof(struct HksParamSet)) { + HKS_LOG_E("check key size: invalid keyfile size: %u", key->size); + return HKS_ERROR_INVALID_KEY_FILE; + } + + struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data; + int32_t ret = HksCheckParamSetValidity(keyParamSet); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key size: paramset invalid failed"); + return HKS_ERROR_INVALID_KEY_FILE; + } + + struct HksParam *keySizeParam = NULL; + ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key size: get param get tag:0x%x failed", HKS_TAG_KEY_SIZE); + return HKS_ERROR_INVALID_KEY_FILE; + } + *keySize = keySizeParam->uint32Param; + return ret; +} + int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize) { switch (alg) { @@ -890,6 +1188,14 @@ int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize case HKS_ALG_RSA: return CheckAndGetKeySize(key, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize), keySize); #endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: +#ifndef _STORAGE_LITE_ + return HksGetDsaKeySize(key, keySize); +#else + return HKS_ERROR_INVALID_ALGORITHM; +#endif +#endif #ifdef HKS_SUPPORT_ECC_C case HKS_ALG_ECC: return CheckAndGetKeySize(key, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize), keySize); @@ -902,6 +1208,10 @@ int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize case HKS_ALG_X25519: case HKS_ALG_ED25519: return CheckAndGetKeySize(key, g_curve25519KeySize, HKS_ARRAY_SIZE(g_curve25519KeySize), keySize); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return CheckAndGetKeySize(key, g_dhKeySize, HKS_ARRAY_SIZE(g_dhKeySize), keySize); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -1013,20 +1323,49 @@ int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inp return ret; } -int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, const struct HksBlob *key, const struct HksBlob *signature) +int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params) { - uint32_t keySize = 0; - int32_t ret = HksGetKeySize(alg, key, &keySize); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get keySize failed!"); - return ret; + if (alg == HKS_ALG_AES) { + return HKS_SUCCESS; } - switch (alg) { + if (((alg == HKS_ALG_ECC) || (alg == HKS_ALG_ED25519)) && (params->purpose.value != HKS_KEY_PURPOSE_VERIFY)) { + HKS_LOG_E("Import key check purpose failed."); + return HKS_ERROR_INVALID_PURPOSE; + } + + if ((alg == HKS_ALG_RSA) && + ((params->purpose.value != HKS_KEY_PURPOSE_VERIFY) && (params->purpose.value != HKS_KEY_PURPOSE_ENCRYPT))) { + HKS_LOG_E("Import key check purpose failed."); + return HKS_ERROR_INVALID_PURPOSE; + } + + if (alg == HKS_ALG_RSA) { #ifdef HKS_SUPPORT_RSA_C + if (params->purpose.value == HKS_KEY_PURPOSE_ENCRYPT) { + return HksCheckValue(params->padding.value, g_rsaCipherPadding, HKS_ARRAY_SIZE(g_rsaCipherPadding)); + } else if (params->purpose.value == HKS_KEY_PURPOSE_VERIFY) { + return HksCheckValue(params->padding.value, g_rsaSignPadding, HKS_ARRAY_SIZE(g_rsaSignPadding)); + } +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif + } + + return HKS_SUCCESS; +} + +int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature) +{ + switch (alg) { +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: return CheckRsaSignature(cmdId, keySize, signature); #endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HKS_SUCCESS; +#endif #ifdef HKS_SUPPORT_ECC_C case HKS_ALG_ECC: return CheckEccSignature(cmdId, keySize, signature); @@ -1065,6 +1404,14 @@ int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const stru return HKS_ERROR_INVALID_PADDING; } break; +#endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: + break; +#endif +#ifdef HKS_SUPPORT_ECC_C + case HKS_ALG_ECC: + break; #endif default: /* other alg no need check padding */ @@ -1116,7 +1463,7 @@ int32_t HksCheckCihperData(uint32_t cmdId, uint32_t alg, const struct ParamsValu const struct HksBlob *inData, const struct HksBlob *outData) { switch (alg) { -#ifdef HKS_SUPPORT_RSA_C +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT) case HKS_ALG_RSA: return CheckRsaCipherData(cmdId, inputParams, inData, outData); #endif diff --git a/frameworks/huks_standard/main/common/src/hks_check_paramset.c b/frameworks/huks_standard/main/common/src/hks_check_paramset.c index afdbfc4dd5fea8a2d9ec5ea7ed2b6977b9aa68d8..2ad51bde8a19e1d4ad50b4dd2fba22122c539f0d 100755 --- a/frameworks/huks_standard/main/common/src/hks_check_paramset.c +++ b/frameworks/huks_standard/main/common/src/hks_check_paramset.c @@ -48,12 +48,24 @@ static uint32_t g_genKeyAlg[] = { #ifdef HKS_SUPPORT_ECC_C HKS_ALG_ECC, #endif +#ifdef HKS_SUPPORT_HMAC_C + HKS_ALG_HMAC, +#endif #ifdef HKS_SUPPORT_X25519_C HKS_ALG_X25519, #endif #ifdef HKS_SUPPORT_ED25519_C HKS_ALG_ED25519, #endif +#ifdef HKS_SUPPORT_DSA_C + HKS_ALG_DSA, +#endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif +#ifdef HKS_SUPPORT_ECDH_C + HKS_ALG_ECDH, +#endif }; static uint32_t g_importKeyAlg[] = { @@ -72,6 +84,9 @@ static uint32_t g_importKeyAlg[] = { #ifdef HKS_SUPPORT_ED25519_C HKS_ALG_ED25519, #endif +#ifdef HKS_SUPPORT_DSA_C + HKS_ALG_DSA, +#endif }; static uint32_t g_cipherAlg[] = { @@ -87,6 +102,9 @@ static uint32_t g_signAlg[] = { #ifdef HKS_SUPPORT_RSA_C HKS_ALG_RSA, #endif +#ifdef HKS_SUPPORT_DSA_C + HKS_ALG_DSA, +#endif #ifdef HKS_SUPPORT_ECC_C HKS_ALG_ECC, #endif @@ -103,12 +121,21 @@ static uint32_t g_agreeAlg[] = { #ifdef HKS_SUPPORT_X25519_C HKS_ALG_X25519, #endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif }; static uint32_t g_agreeAlgLocal[] = { +#ifdef HKS_SUPPORT_ECDH_C + HKS_ALG_ECDH, +#endif #ifdef HKS_SUPPORT_X25519_C HKS_ALG_X25519, #endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif }; #endif /* _CUT_AUTHENTICATE_ */ @@ -128,27 +155,48 @@ static uint32_t g_deriveAlgLocal[] = { }; static uint32_t g_digest[] = { + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, HKS_DIGEST_SHA256, HKS_DIGEST_SHA384, HKS_DIGEST_SHA512 }; static uint32_t g_macDigest[] = { - HKS_DIGEST_SHA256 + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, + HKS_DIGEST_SHA256, + HKS_DIGEST_SHA384, + HKS_DIGEST_SHA512, }; +#ifdef HKS_SUPPORT_AES_C static uint32_t g_aesKeySizeLocal[] = { - HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128), - HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192), - HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256) + HKS_AES_KEY_SIZE_128, + HKS_AES_KEY_SIZE_192, + HKS_AES_KEY_SIZE_256, }; +#endif +#ifdef HKS_SUPPORT_RSA_C +static uint32_t g_rsaKeySizeLocal[] = { + HKS_RSA_KEY_SIZE_512, + HKS_RSA_KEY_SIZE_768, + HKS_RSA_KEY_SIZE_1024, + HKS_RSA_KEY_SIZE_2048, + HKS_RSA_KEY_SIZE_3072, + HKS_RSA_KEY_SIZE_4096, +}; +#endif static uint32_t g_cipherAlgLocal[] = { #ifdef HKS_SUPPORT_AES_C HKS_ALG_AES, #endif +#ifdef HKS_SUPPORT_RSA_C + HKS_ALG_RSA, +#endif }; -static int32_t CheckAndGetAlgorithm(const struct HksParamSet *paramSet, const uint32_t *expectAlg, - uint32_t expectCnt, uint32_t *alg) +static int32_t CheckAndGetAlgorithm( + const struct HksParamSet *paramSet, const uint32_t *expectAlg, uint32_t expectCnt, uint32_t *alg) { struct HksParam *algParam = NULL; int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam); @@ -167,8 +215,8 @@ static int32_t CheckAndGetAlgorithm(const struct HksParamSet *paramSet, const ui return ret; } -static int32_t CheckAndGetDigest(const struct HksParamSet *paramSet, const uint32_t *expectDigest, - uint32_t expectCnt, uint32_t *digest) +static int32_t CheckAndGetDigest( + const struct HksParamSet *paramSet, const uint32_t *expectDigest, uint32_t expectCnt, uint32_t *digest) { struct HksParam *digestParam = NULL; int32_t ret = HksGetParam(paramSet, HKS_TAG_DIGEST, &digestParam); @@ -188,8 +236,7 @@ static int32_t CheckAndGetDigest(const struct HksParamSet *paramSet, const uint3 } #ifndef _CUT_AUTHENTICATE_ -static int32_t CheckGenKeyParamsByAlg(uint32_t alg, const struct HksParamSet *paramSet, - struct ParamsValues *params) +static int32_t CheckGenKeyParamsByAlg(uint32_t alg, const struct HksParamSet *paramSet, struct ParamsValues *params) { int32_t ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_GEN_KEY, paramSet, params); if (ret != HKS_SUCCESS) { @@ -205,10 +252,10 @@ static int32_t CheckGenKeyParamsByAlg(uint32_t alg, const struct HksParamSet *pa return HksCheckGenKeyMutableParams(alg, params); } -static int32_t CheckGenKeyMacDeriveParams(uint32_t alg, uint32_t inputPurpose, const struct HksParamSet *paramSet, - struct ParamsValues *params) +static int32_t CheckGenKeyMacDeriveParams( + uint32_t alg, uint32_t inputPurpose, const struct HksParamSet *paramSet, struct ParamsValues *params) { - if (alg != HKS_ALG_AES) { + if (alg != HKS_ALG_AES && alg != HKS_ALG_HMAC) { HKS_LOG_E("check mac or derive, not aes alg, alg: %u", alg); return HKS_ERROR_INVALID_PURPOSE; } @@ -219,7 +266,11 @@ static int32_t CheckGenKeyMacDeriveParams(uint32_t alg, uint32_t inputPurpose, c return ret; } - ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_GEN_DERIVE_KEY, paramSet, params); + if (inputPurpose == HKS_KEY_PURPOSE_MAC) { + ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_GEN_MAC_KEY, paramSet, params); + } else { + ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_GEN_DERIVE_KEY, paramSet, params); + } if (ret != HKS_SUCCESS) { HKS_LOG_E("get input params by algorithm failed, ret = %d", ret); return ret; @@ -282,30 +333,16 @@ static int32_t CheckImportKeySize(uint32_t alg, const struct ParamsValues *param ret = HKS_ERROR_INVALID_KEY_INFO; } break; +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: + break; +#endif default: return HKS_ERROR_INVALID_ALGORITHM; } return ret; } -static int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params) -{ - if (alg == HKS_ALG_AES) { - return HKS_SUCCESS; - } - - if (((alg == HKS_ALG_RSA) || (alg == HKS_ALG_ECC) || (alg == HKS_ALG_ED25519)) && - (params->purpose.value != HKS_KEY_PURPOSE_VERIFY)) { - return HKS_ERROR_INVALID_PURPOSE; - } - - if ((alg == HKS_ALG_RSA) && (params->padding.value != HKS_PADDING_PSS)) { - return HKS_ERROR_INVALID_PADDING; - } - - return HKS_SUCCESS; -} - static int32_t CheckSignVerifyParamsByAlg(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams) { int32_t ret = HksCheckFixedParams(alg, HKS_CHECK_TYPE_USE_KEY, inputParams); @@ -323,8 +360,8 @@ static int32_t CheckSignVerifyParamsByAlg(uint32_t cmdId, uint32_t alg, const st } #endif /* _CUT_AUTHENTICATE_ */ -static int32_t CheckCipherParamsByAlg(uint32_t cmdId, uint32_t alg, const struct HksParamSet *paramSet, - const struct ParamsValues *inputParams) +static int32_t CheckCipherParamsByAlg( + uint32_t cmdId, uint32_t alg, const struct HksParamSet *paramSet, const struct ParamsValues *inputParams) { int32_t ret = HksCheckFixedParams(alg, HKS_CHECK_TYPE_USE_KEY, inputParams); if (ret != HKS_SUCCESS) { @@ -444,7 +481,14 @@ int32_t HksCoreCheckSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, return ret; } - ret = HksCheckSignature(cmdId, alg, key, signature); + uint32_t keySize = 0; + ret = HksGetKeySize(alg, key, &keySize); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get keySize failed!"); + return ret; + } + + ret = HksCheckSignature(cmdId, alg, keySize, signature); if (ret != HKS_SUCCESS) { HKS_LOG_E("check signature failed, ret = %d", ret); } @@ -460,6 +504,49 @@ int32_t HksCoreCheckSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, #endif } +int32_t HksLocalCheckSignVerifyParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ +#ifdef HKS_SUPPORT_API_SIGN_VERIFY + (void)srcData; + uint32_t alg; + int32_t ret = CheckAndGetAlgorithm(paramSet, g_signAlg, HKS_ARRAY_SIZE(g_signAlg), &alg); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check and get alg failed"); + return ret; + } + + struct ParamsValues params; + (void)memset_s(¶ms, sizeof(params), 0, sizeof(params)); + + ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_USE_KEY, paramSet, ¶ms); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("sign or verify get input params failed, ret = %d", ret); + return ret; + } + + ret = CheckSignVerifyParamsByAlg(cmdId, alg, ¶ms); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("sign or verify check params failed, ret = %d", ret); + return ret; + } + + ret = HksCheckSignature(cmdId, alg, keySize, signature); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check signature failed, ret = %d", ret); + } + + return ret; +#else + (void)cmdId; + (void)keySize; + (void)paramSet; + (void)srcData; + (void)signature; + return HKS_ERROR_NOT_SUPPORTED; +#endif +} + int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck) { @@ -478,11 +565,18 @@ int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const str uint32_t keySize = 0; if (isLocalCheck) { - if ((privateKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256)) || - (peerPublicKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256))) { - return HKS_ERROR_INVALID_KEY_SIZE; + if (alg == HKS_ALG_ED25519) { + if ((privateKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256)) || + (peerPublicKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256))) { + return HKS_ERROR_INVALID_KEY_SIZE; + } + } + + if (alg == HKS_ALG_DH || alg == HKS_ALG_ECC || alg == HKS_ALG_ECDH) { + keySize = ((struct HksKeyMaterialHeader *)privateKey->data)->keySize; + } else if (alg == HKS_ALG_ED25519) { + keySize = privateKey->size * HKS_BITS_PER_BYTE; } - keySize = privateKey->size * HKS_BITS_PER_BYTE; } else { ret = HksGetKeySize(alg, privateKey, &keySize); if (ret != HKS_SUCCESS) { @@ -542,22 +636,34 @@ int32_t HksCoreCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, cons } #endif /* _CUT_AUTHENTICATE_ */ -int32_t HksLocalCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, +int32_t HksLocalCheckCipherParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, const struct HksBlob *inData, const struct HksBlob *outData) { - int32_t ret = HksCheckValue(key->size, g_aesKeySizeLocal, HKS_ARRAY_SIZE(g_aesKeySizeLocal)); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("keySize value %u not expected", key->size); - return HKS_ERROR_INVALID_KEY_SIZE; - } - uint32_t alg; - ret = CheckAndGetAlgorithm(paramSet, g_cipherAlgLocal, HKS_ARRAY_SIZE(g_cipherAlgLocal), &alg); + int32_t ret = CheckAndGetAlgorithm(paramSet, g_cipherAlgLocal, HKS_ARRAY_SIZE(g_cipherAlgLocal), &alg); if (ret != HKS_SUCCESS) { HKS_LOG_E("check alg failed"); return ret; } + if (alg == HKS_ALG_AES) { +#ifdef HKS_SUPPORT_AES_C + ret = HksCheckValue(keySize, g_aesKeySizeLocal, HKS_ARRAY_SIZE(g_aesKeySizeLocal)); +#else + ret = HKS_ERROR_NOT_SUPPORTED; +#endif + } else if (alg == HKS_ALG_RSA) { +#ifdef HKS_SUPPORT_RSA_C + ret = HksCheckValue(keySize, g_rsaKeySizeLocal, HKS_ARRAY_SIZE(g_rsaKeySizeLocal)); +#else + ret = HKS_ERROR_NOT_SUPPORTED; +#endif + } + if (ret != HKS_SUCCESS) { + HKS_LOG_E("keySize value %u not expected", keySize); + return HKS_ERROR_INVALID_KEY_SIZE; + } + struct ParamsValues params; (void)memset_s(¶ms, sizeof(params), 0, sizeof(params)); @@ -641,8 +747,8 @@ static int32_t CheckMacPurpose(const struct HksParamSet *paramSet) return HKS_SUCCESS; } -static int32_t CheckMacOutput(const struct HksBlob *key, const struct HksParamSet *paramSet, - const struct HksBlob *mac, bool isLocalCheck) +static int32_t CheckMacOutput( + const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *mac, bool isLocalCheck) { uint32_t digest; int32_t ret; @@ -688,4 +794,3 @@ int32_t HksCoreCheckMacParams(const struct HksBlob *key, const struct HksParamSe return CheckMacOutput(key, paramSet, mac, isLocalCheck); } - diff --git a/frameworks/huks_standard/main/common/src/hks_common_check.c b/frameworks/huks_standard/main/common/src/hks_common_check.c index 0d2497b3ef928ca91f12fa756df5b2effce90056..4ace2c5f64e211fd98360e69868f95a536c83092 100644 --- a/frameworks/huks_standard/main/common/src/hks_common_check.c +++ b/frameworks/huks_standard/main/common/src/hks_common_check.c @@ -137,6 +137,15 @@ int32_t HksCheckBlobAndParamSet(const struct HksBlob *data, const struct HksPara int32_t HksGetDigestLen(uint32_t digest, uint32_t *digestLen) { switch (digest) { + case HKS_DIGEST_MD5: + *digestLen = HKS_DIGEST_MD5_LEN; + break; + case HKS_DIGEST_SHA1: + *digestLen = HKS_DIGEST_SHA1_LEN; + break; + case HKS_DIGEST_SHA224: + *digestLen = HKS_DIGEST_SHA224_LEN; + break; case HKS_DIGEST_SHA256: *digestLen = HKS_DIGEST_SHA256_LEN; break; diff --git a/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c b/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c index c9e3a9962147aa01472ed0fab94a910dcf0c9594..0cf012eb74c2c3d52088e6e6f14abe093ae7fc71 100755 --- a/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c +++ b/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c @@ -13,6 +13,12 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + #include "hks_crypto_adapter.h" #include "hks_common_check.h" @@ -97,8 +103,8 @@ void HksFillKeyDerivationParam(const struct HksParamSet *paramSet, struct HksKey } } -int32_t HksFillAeadParam(const struct HksParamSet *paramSet, struct HksBlob *inputText, struct HksUsageSpec *usageSpec, - bool isEncrypt) +int32_t HksFillAeadParam( + const struct HksParamSet *paramSet, struct HksBlob *inputText, struct HksUsageSpec *usageSpec, bool isEncrypt) { struct HksParam *nonceParam = NULL; int32_t ret = HksGetParam(paramSet, HKS_TAG_NONCE, &nonceParam); @@ -165,8 +171,8 @@ int32_t HksFillIvParam(const struct HksParamSet *paramSet, struct HksUsageSpec * return HKS_SUCCESS; } -int32_t HksBuildCipherUsageSpec(const struct HksParamSet *paramSet, bool isEncrypt, struct HksBlob *inputText, - struct HksUsageSpec **outUsageSpec) +int32_t HksBuildCipherUsageSpec( + const struct HksParamSet *paramSet, bool isEncrypt, struct HksBlob *inputText, struct HksUsageSpec **outUsageSpec) { bool isAes = false; bool isAeMode = false; @@ -183,6 +189,11 @@ int32_t HksBuildCipherUsageSpec(const struct HksParamSet *paramSet, bool isEncry } HksFillUsageSpec(paramSet, usageSpec); + + if (usageSpec->algType == HKS_ALG_RSA && usageSpec->digest == HKS_DIGEST_NONE) { + usageSpec->digest = HKS_DIGEST_SHA1; + } + if (!isAes) { *outUsageSpec = usageSpec; return HKS_SUCCESS; @@ -204,8 +215,8 @@ int32_t HksBuildCipherUsageSpec(const struct HksParamSet *paramSet, bool isEncry return HKS_SUCCESS; } -int32_t HksGetEncryptAeTag(const struct HksParamSet *paramSet, const struct HksBlob *inData, - struct HksBlob *outData, struct HksBlob *tagAead) +int32_t HksGetEncryptAeTag( + const struct HksParamSet *paramSet, const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *tagAead) { bool isAes = false; bool isAeMode = false; @@ -349,12 +360,13 @@ static int32_t FormatCurve25519Key(const struct HksBlob *keyIn, struct HksParamS struct HksParam params[] = { { .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, - .blob = { keyMaterial->pubKeySize, keyIn->data + sizeof(struct KeyMaterial25519) } + .blob = { keyMaterial->pubKeySize, keyIn->data + sizeof(struct KeyMaterial25519) }, }, { .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, - .blob = { keyMaterial->priKeySize, keyIn->data + sizeof(struct KeyMaterial25519) + keyMaterial->pubKeySize } - } + .blob = { keyMaterial->priKeySize, + keyIn->data + sizeof(struct KeyMaterial25519) + keyMaterial->pubKeySize }, + }, }; return BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); @@ -392,12 +404,217 @@ int32_t GetCurve25519FromKeyMaterial(const bool isPubKey, const struct HksBlob * return HKS_SUCCESS; } +#ifdef HKS_SUPPORT_AES_C +static int32_t FormatAesKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + struct HksParam params[] = { + { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + return BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); +} +#endif + +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) +static int32_t FormatRsaKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + if (keyIn->size < sizeof(struct KeyMaterialRsa)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)keyIn->data; + uint32_t publicKeySize = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; + if (keyIn->size < publicKeySize) { + HKS_LOG_E("invalid key info."); + return HKS_ERROR_INVALID_KEY_INFO; + } + + uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); + if (publicKey == NULL) { + HKS_LOG_E("malloc public key failed."); + return HKS_ERROR_MALLOC_FAIL; + } + + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + ((struct KeyMaterialRsa *)publicKey)->dSize = 0; + + struct HksParam params[] = { + { + .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, + .blob = { publicKeySize, publicKey }, + }, + { + .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); + memset_s(publicKey, publicKeySize, 0x00, publicKeySize); + HksFree(publicKey); + return ret; +} +#endif + +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) +static int32_t FormatHmacKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + struct HksParam params[] = { + { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + return BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); +} +#endif + +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) +static int32_t FormatDsaKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + if (keyIn->size < sizeof(struct KeyMaterialDsa)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)keyIn->data; + uint32_t publicKeySize = sizeof(struct KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + + keyMaterial->qSize + keyMaterial->gSize; + if (keyIn->size < publicKeySize) { + HKS_LOG_E("invalid key info."); + return HKS_ERROR_INVALID_KEY_INFO; + } + + uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); + if (publicKey == NULL) { + HKS_LOG_E("malloc key failed."); + HKS_FREE_PTR(publicKey); + return HKS_ERROR_MALLOC_FAIL; + } + + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, sizeof(struct KeyMaterialDsa)); + uint32_t inOffset = sizeof(struct KeyMaterialDsa); + uint32_t outOffset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize; + (void)memcpy_s(publicKey + inOffset, publicKeySize - inOffset, keyIn->data + outOffset, publicKeySize - inOffset); + ((struct KeyMaterialDsa *)publicKey)->xSize = 0; + + struct HksParam params[] = { + { + .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, + .blob = { publicKeySize, publicKey }, + }, + { + .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + + int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); + memset_s(publicKey, publicKeySize, 0x00, publicKeySize); + HksFree(publicKey); + return ret; +} +#endif + +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) +static int32_t FormatEccKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + if (keyIn->size < sizeof(struct KeyMaterialEcc)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)keyIn->data; + uint32_t publicKeySize = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + if (keyIn->size < publicKeySize) { + HKS_LOG_E("invalid key info."); + return HKS_ERROR_INVALID_KEY_INFO; + } + + uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); + if (publicKey == NULL) { + HKS_LOG_E("malloc public key failed."); + return HKS_ERROR_MALLOC_FAIL; + } + + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + ((struct KeyMaterialEcc *)publicKey)->zSize = 0; + + struct HksParam params[] = { + { + .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, + .blob = { publicKeySize, publicKey }, + }, + { + .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); + memset_s(publicKey, publicKeySize, 0x00, publicKeySize); + HksFree(publicKey); + return ret; +} +#endif + +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) +static int32_t FormatDhKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + if (keyIn->size < sizeof(struct KeyMaterialDh)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyIn->data; + uint32_t publicKeySize = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + if (keyIn->size < publicKeySize) { + HKS_LOG_E("invalid key info."); + return HKS_ERROR_INVALID_KEY_INFO; + } + + uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); + if (publicKey == NULL) { + HKS_LOG_E("malloc public key failed."); + return HKS_ERROR_MALLOC_FAIL; + } + + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + ((struct KeyMaterialDh *)publicKey)->priKeySize = 0; + + struct HksParam params[] = { + { + .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, + .blob = { publicKeySize, publicKey }, + }, + { + .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); + memset_s(publicKey, publicKeySize, 0x00, publicKeySize); + HksFree(publicKey); + return ret; +} +#endif + int32_t HksSetKeyToMaterial(uint32_t alg, bool isPubKey, const struct HksBlob *key, struct HksBlob *keyMaterial) { switch (alg) { case HKS_ALG_X25519: case HKS_ALG_ED25519: return SetCurve25519KeyMaterial(isPubKey, key, keyMaterial); + case HKS_ALG_RSA: + case HKS_ALG_DSA: + case HKS_ALG_ECC: + case HKS_ALG_ECDH: + case HKS_ALG_DH: + keyMaterial->size = key->size; + keyMaterial->data = HksMalloc(keyMaterial->size); + if (keyMaterial->data != NULL) { + (void)memcpy_s(keyMaterial->data, keyMaterial->size, key->data, key->size); + return HKS_SUCCESS; + } else { + return HKS_ERROR_MALLOC_FAIL; + } default: HKS_LOG_E("alg not support"); return HKS_ERROR_INVALID_ALGORITHM; @@ -422,6 +639,31 @@ int32_t HksFormatKeyFromMaterial(uint32_t alg, const struct HksBlob *keyMaterial case HKS_ALG_X25519: case HKS_ALG_ED25519: return FormatCurve25519Key(keyMaterial, paramSetOut); +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + case HKS_ALG_AES: + return FormatAesKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + case HKS_ALG_RSA: + return FormatRsaKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) + case HKS_ALG_HMAC: + return FormatHmacKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) + case HKS_ALG_DSA: + return FormatDsaKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + case HKS_ALG_ECC: + case HKS_ALG_ECDH: + return FormatEccKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return FormatDhKey(keyMaterial, paramSetOut); +#endif default: HKS_LOG_E("alg not support"); return HKS_ERROR_INVALID_ALGORITHM; diff --git a/frameworks/huks_standard/main/core/src/hks_local_engine.c b/frameworks/huks_standard/main/core/src/hks_local_engine.c index 18e26eff47aec198bea1255e054d19c622e443af..be5937bb39f9a9077a6d6ab913bd37cd45989533 100755 --- a/frameworks/huks_standard/main/core/src/hks_local_engine.c +++ b/frameworks/huks_standard/main/core/src/hks_local_engine.c @@ -90,33 +90,17 @@ int32_t HksLocalBnExpMod(struct HksBlob *x, const struct HksBlob *a, const struc #ifndef _CUT_AUTHENTICATE_ static int32_t CheckLocalGenerateKeyParams(const struct HksParamSet *paramSetIn, struct HksParamSet *paramSetOut) { + int32_t ret; if ((HksCheckParamSetValidity(paramSetIn) != HKS_SUCCESS) || (paramSetOut == NULL)) { return HKS_ERROR_INVALID_ARGUMENT; } - struct HksParam *algParam = NULL; - int32_t ret = HksGetParam(paramSetIn, HKS_TAG_ALGORITHM, &algParam); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get param alg failed"); - return HKS_ERROR_CHECK_GET_ALG_FAIL; - } - - if (algParam->uint32Param != HKS_ALG_X25519) { - HKS_LOG_E("invalid alg: %u", algParam->uint32Param); - return HKS_ERROR_INVALID_ALGORITHM; - } - - struct HksParam *keySizeParam = NULL; - ret = HksGetParam(paramSetIn, HKS_TAG_KEY_SIZE, &keySizeParam); + ret = HksCoreCheckGenKeyParams(NULL, paramSetIn, NULL, NULL); if (ret != HKS_SUCCESS) { - HKS_LOG_E("get param key size failed"); - return HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL; + HKS_LOG_E("check generate key parameter failed ret = %x.", ret); + return HKS_ERROR_INVALID_ARGUMENT; } - if (keySizeParam->uint32Param != HKS_CURVE25519_KEY_SIZE_256) { - HKS_LOG_E("invalid key size: %u", keySizeParam->uint32Param); - return HKS_ERROR_INVALID_KEY_SIZE; - } return HKS_SUCCESS; } @@ -213,7 +197,24 @@ static int32_t CheckLocalCipherParams(uint32_t cmdId, const struct HksBlob *key, if (HksCheckBlob3AndParamSet(key, inputText, outputText, paramSet) != HKS_SUCCESS) { return HKS_ERROR_INVALID_ARGUMENT; } - return HksLocalCheckCipherParams(cmdId, key, paramSet, inputText, outputText); + + struct HksParam *outParam = NULL; + if (HksGetParam(paramSet, HKS_TAG_ALGORITHM, &outParam) != HKS_SUCCESS) { + HKS_LOG_E("get tag algorithm failed."); + return HKS_ERROR_CHECK_GET_ALG_FAIL; + } + + uint32_t keySize = 0; + if (outParam->uint32Param == HKS_ALG_AES) { + keySize = key->size * HKS_BITS_PER_BYTE; + } else if (outParam->uint32Param == HKS_ALG_RSA) { + const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)key->data; + keySize = keyMaterial->keySize; + } else { + return HKS_ERROR_INVALID_ALGORITHM; + } + + return HksLocalCheckCipherParams(cmdId, keySize, paramSet, inputText, outputText); } static int32_t EncryptAndDecrypt(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, @@ -280,41 +281,83 @@ int32_t HksLocalDeriveKey(const struct HksParamSet *paramSet, const struct HksBl } #ifndef _CUT_AUTHENTICATE_ -static int32_t CheckLocalVerifyParams(const struct HksBlob *key, const struct HksParamSet *paramSet, +static int32_t CheckLocalSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, const struct HksBlob *signature) { if (HksCheckBlob3AndParamSet(key, srcData, signature, paramSet) != HKS_SUCCESS) { return HKS_ERROR_INVALID_ARGUMENT; } - if (key->size != (HKS_CURVE25519_KEY_SIZE_256 / HKS_BITS_PER_BYTE)) { - HKS_LOG_E("invalid key size: %u", key->size); - return HKS_ERROR_INVALID_KEY_SIZE; + struct HksParam *algParam = NULL; + int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get param algorithm failed"); + return HKS_ERROR_CHECK_GET_ALG_FAIL; } - if (signature->size < HKS_SIGNATURE_MIN_SIZE) { - HKS_LOG_E("signature size too small, size: %u", signature->size); - return HKS_ERROR_INVALID_SIGNATURE_SIZE; + uint32_t keySize = 0; + if (algParam->uint32Param == HKS_ALG_RSA) { + keySize = ((struct KeyMaterialRsa *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_DSA) { + keySize = ((struct KeyMaterialDsa *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_ECC) { + keySize = ((struct KeyMaterialEcc *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_ED25519) { + keySize = key->size * HKS_BITS_PER_BYTE; } - struct HksParam *purposeParam = NULL; - int32_t ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &purposeParam); + ret = HksLocalCheckSignVerifyParams(cmdId, keySize, paramSet, srcData, signature); if (ret != HKS_SUCCESS) { - HKS_LOG_E("get param purpose failed"); - return HKS_ERROR_CHECK_GET_PURPOSE_FAIL; + return ret; } - if ((purposeParam->uint32Param & HKS_KEY_PURPOSE_VERIFY) == 0) { - HKS_LOG_E("invalid purpose: 0x%x", purposeParam->uint32Param); - return HKS_ERROR_INVALID_PURPOSE; + + if (algParam->uint32Param == HKS_ALG_ED25519) { + if (key->size != (HKS_CURVE25519_KEY_SIZE_256 / HKS_BITS_PER_BYTE)) { + HKS_LOG_E("invalid key size: %u", key->size); + return HKS_ERROR_INVALID_KEY_SIZE; + } + + if (signature->size < HKS_SIGNATURE_MIN_SIZE) { + HKS_LOG_E("signature size too small, size: %u", signature->size); + return HKS_ERROR_INVALID_SIGNATURE_SIZE; + } } return HKS_SUCCESS; } -int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, - const struct HksBlob *srcData, const struct HksBlob *signature) +int32_t HksLocalSign(const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, + struct HksBlob *signature) +{ + int32_t ret = CheckLocalSignVerifyParams(HKS_CMD_ID_SIGN, key, paramSet, srcData, signature); + if (ret != HKS_SUCCESS) { + return ret; + } + + struct HksUsageSpec usageSpec = {0}; + HksFillUsageSpec(paramSet, &usageSpec); + + struct HksBlob keyMaterial = { 0, NULL }; + ret = HksSetKeyToMaterial(usageSpec.algType, false, key, &keyMaterial); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("set key to material failed, ret:%x!", ret); + return ret; + } + + ret = HksCryptoHalSign(&keyMaterial, &usageSpec, srcData, signature); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("local engine verify failed, ret:%x!", ret); + } + + (void)memset_s(keyMaterial.data, keyMaterial.size, 0, keyMaterial.size); + HKS_FREE_PTR(keyMaterial.data); + return ret; +} + +int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, + const struct HksBlob *signature) { - int32_t ret = CheckLocalVerifyParams(key, paramSet, srcData, signature); + int32_t ret = CheckLocalSignVerifyParams(HKS_CMD_ID_VERIFY, key, paramSet, srcData, signature); if (ret != HKS_SUCCESS) { return ret; } @@ -329,7 +372,6 @@ int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *para return ret; } - /* Only ed25519 is allowed here */ ret = HksCryptoHalVerify(&keyMaterial, &usageSpec, srcData, signature); if (ret != HKS_SUCCESS) { HKS_LOG_E("local engine verify failed, ret:%x!", ret); diff --git a/frameworks/huks_standard/main/crypto_engine/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/BUILD.gn index 4d18709c1c9a13a3fef222e245d64c18e17c8a4e..5dc4e875e7ba6757954259ef814fa2e6d51fab9b 100644 --- a/frameworks/huks_standard/main/crypto_engine/BUILD.gn +++ b/frameworks/huks_standard/main/crypto_engine/BUILD.gn @@ -11,6 +11,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +import("//base/security/huks/huks.gni") import("//build/ohos.gni") ohos_static_library("libhuks_crypto_engine_standard_static") { @@ -21,6 +22,11 @@ ohos_static_library("libhuks_crypto_engine_standard_static") { ] subsystem_name = "security" part_name = "huks_standard" - public_deps = [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/openssl:libhuks_openssl_standard_static" ] + if (use_crypto_lib == "openssl") { + public_deps = [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/openssl:libhuks_openssl_standard_static" ] + } + if (use_crypto_lib == "mbedtls") { + public_deps = [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/mbedtls:libhuks_mbedtls_standard_static" ] + } complete_static_lib = true } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..4491f07ffaaba523bd3e05fc85d59c3ec37de061 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn @@ -0,0 +1,62 @@ +# Copyright (C) 2021 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. + +import("//build/ohos.gni") + +config("huks_config") { + include_dirs = [ "include" ] +} + +ohos_static_library("libhuks_mbedtls_standard_static") { + subsystem_name = "security" + part_name = "huks_standard" + public_configs = [ ":huks_config" ] + + include_dirs = [ + "//utils/native/base/include", + "//third_party/mbedtls/include/", + "//third_party/openssl/include/", + "//third_party/openssl/crypto/ec/", + ] + + defines = [ + "L2_STANDARD", + "_HARDWARE_ROOT_KEY_", + "_HUKS_LOG_ENABLE_", + ] + sources = [ + "src/hks_crypto_ed25519.c", + "src/hks_mbedtls_aes.c", + "src/hks_mbedtls_bn.c", + "src/hks_mbedtls_common.c", + "src/hks_mbedtls_dh.c", + "src/hks_mbedtls_dsa.c", + "src/hks_mbedtls_ecc.c", + "src/hks_mbedtls_ecdh.c", + "src/hks_mbedtls_ecdsa.c", + "src/hks_mbedtls_engine.c", + "src/hks_mbedtls_hash.c", + "src/hks_mbedtls_hmac.c", + "src/hks_mbedtls_kdf.c", + "src/hks_mbedtls_rsa.c", + "src/hks_mbedtls_x25519.c", + ] + + deps = [ + "//base/security/huks/frameworks/huks_standard/main/common:libhuks_common_standard_static", + "//third_party/mbedtls:mbedtls_shared", + "//third_party/openssl:libcrypto_static", + ] + cflags_cc = [ "-DHILOG_ENABLE" ] + complete_static_lib = true +} diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h index 91fc123908a8421af3de6591b13218c8e430f1dd..2d9b43f79555a7216a2a99428cf5c5da0b9966e8 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h @@ -29,15 +29,17 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_AES_C #ifdef HKS_SUPPORT_AES_GENERATE_KEY int32_t HksMbedtlsAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); -#endif +#endif /* HKS_SUPPORT_AES_GENERATE_KEY */ int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead); int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText); +#endif /* HKS_SUPPORT_AES_C */ #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h new file mode 100755 index 0000000000000000000000000000000000000000..d7a7f3664e59a51a0c780bb574cec760a69e0fef --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020-2021 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. + */ + +#ifndef HKS_MBEDTLS_DH_H +#define HKS_MBEDTLS_DH_H + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_crypto_hal.h" +#include "hks_type_inner.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HKS_SUPPORT_DH_C +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +int32_t HksMbedtlsDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksMbedtlsDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ +#endif /* HKS_SUPPORT_DH_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_MBEDTLS_DH_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h new file mode 100755 index 0000000000000000000000000000000000000000..a08eaffbabf5febe2271e28e9230b608ec8f2ebc --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2020-2021 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. + */ + +#ifndef HKS_MBEDTLS_DSA_H +#define HKS_MBEDTLS_DSA_H + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_crypto_hal.h" +#include "hks_type_inner.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HKS_SUPPORT_DSA_C +#ifdef HKS_SUPPORT_DSA_GENERATE_KEY +int32_t HksMbedtlsDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DSA_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DSA_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDsaPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +int32_t HksMbedtlsDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksMbedtlsDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_DSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_DSA_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_MBEDTLS_DSA_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h index 055f34377180fd7076fa966de065a9f5379aa995..d8f42e3cd65d3b54f9b083fa07c72b621fa6a174 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h @@ -29,11 +29,8 @@ extern "C" { #endif -int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, struct HksBlob *signature); - -int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, const struct HksBlob *signature); +int32_t HksMbedtlsEcdsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature, bool isVerify); #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_engine.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_engine.h new file mode 100755 index 0000000000000000000000000000000000000000..bca71b3acde5e141146075c5aaae791101627eb9 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_engine.h @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_MBEDTLS_ENGINE_H +#define HKS_MBEDTLS_ENGINE_H + +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h index 68b7888c6b834bfca5897c50b93246ee0e0e2230..1b48eeaf7eb9a92514778f124ccb711945fa9a5d 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h @@ -22,12 +22,17 @@ #include "hks_config.h" #endif -#include "hks_type.h" +#include "hks_crypto_hal.h" +#include "hks_type_inner.h" #ifdef __cplusplus extern "C" { #endif +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY +int32_t HksMbedtlsHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif + int32_t HksMbedtlsHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c index aa4f6af39ebaec60fea1ea2f6fcfbb0c521d6588..be85a3a8f742db8952d6f4261e832aa7b5abcf35 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c @@ -39,6 +39,11 @@ #ifdef HKS_SUPPORT_AES_GENERATE_KEY int32_t HksMbedtlsAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) { + if (spec->keyLen != HKS_AES_KEY_SIZE_128 && spec->keyLen != HKS_AES_KEY_SIZE_192 && + spec->keyLen != HKS_AES_KEY_SIZE_256) { + return HKS_ERROR_INVALID_ARGUMENT; + } + const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE; uint8_t *outKey = (uint8_t *)HksMalloc(keyByteLen); @@ -96,11 +101,16 @@ static int32_t AesCbcNoPaddingCrypt(const struct HksBlob *key, const struct HksC uint8_t tmpIv[HKS_AES_CBC_NOPADDING_IV_SIZE]; if (memcpy_s(tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE, cipherParam->iv.data, cipherParam->iv.size) != EOK) { HKS_LOG_E("Memcpy temp iv failed!"); + ret = HKS_ERROR_INVALID_IV; break; } - ret = mbedtls_aes_crypt_cbc(&ctx, (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT), - message->size, tmpIv, message->data, cipherText->data); + ret = mbedtls_aes_crypt_cbc(&ctx, + (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT), + message->size, + tmpIv, + message->data, + cipherText->data); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtks aes cbc crypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -139,8 +149,13 @@ static int32_t AesCbcPkcs7Crypt(const struct HksBlob *key, const struct HksCiphe break; } - ret = mbedtls_cipher_crypt(&ctx, cipherParam->iv.data, cipherParam->iv.size, - message->data, message->size, cipherText->data, (size_t *)&(cipherText->size)); + ret = mbedtls_cipher_crypt(&ctx, + cipherParam->iv.data, + cipherParam->iv.size, + message->data, + message->size, + cipherText->data, + (size_t *)&(cipherText->size)); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls cbc pkcs7 crypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -190,9 +205,17 @@ static int32_t AesEncryptGcm(const struct HksBlob *key, const struct HksUsageSpe } const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam); - ret = mbedtls_gcm_crypt_and_tag(&ctx, MBEDTLS_GCM_ENCRYPT, message->size, - aeadParam->nonce.data, aeadParam->nonce.size, aeadParam->aad.data, aeadParam->aad.size, - message->data, cipherText->data, tagAead->size, tagAead->data); + ret = mbedtls_gcm_crypt_and_tag(&ctx, + MBEDTLS_GCM_ENCRYPT, + message->size, + aeadParam->nonce.data, + aeadParam->nonce.size, + aeadParam->aad.data, + aeadParam->aad.size, + message->data, + cipherText->data, + tagAead->size, + tagAead->data); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -221,9 +244,16 @@ static int32_t AesDecryptGcm(const struct HksBlob *key, const struct HksUsageSpe } const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam); - ret = mbedtls_gcm_auth_decrypt(&ctx, message->size, aeadParam->nonce.data, aeadParam->nonce.size, - aeadParam->aad.data, aeadParam->aad.size, aeadParam->tagDec.data, aeadParam->tagDec.size, - message->data, cipherText->data); + ret = mbedtls_gcm_auth_decrypt(&ctx, + message->size, + aeadParam->nonce.data, + aeadParam->nonce.size, + aeadParam->aad.data, + aeadParam->aad.size, + aeadParam->tagDec.data, + aeadParam->tagDec.size, + message->data, + cipherText->data); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls aes gcm decrypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -253,9 +283,16 @@ static int32_t AesEncryptCcm(const struct HksBlob *key, const struct HksUsageSpe } const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam); - ret = mbedtls_ccm_encrypt_and_tag(&ctx, message->size, - aeadParam->nonce.data, aeadParam->nonce.size, aeadParam->aad.data, aeadParam->aad.size, - message->data, cipherText->data, tagAead->data, tagAead->size); + ret = mbedtls_ccm_encrypt_and_tag(&ctx, + message->size, + aeadParam->nonce.data, + aeadParam->nonce.size, + aeadParam->aad.data, + aeadParam->aad.size, + message->data, + cipherText->data, + tagAead->data, + tagAead->size); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls aes ccm encrypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -284,9 +321,16 @@ static int32_t AesDecryptCcm(const struct HksBlob *key, const struct HksUsageSpe } const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam); - ret = mbedtls_ccm_auth_decrypt(&ctx, message->size, aeadParam->nonce.data, aeadParam->nonce.size, - aeadParam->aad.data, aeadParam->aad.size, message->data, cipherText->data, - aeadParam->tagDec.data, aeadParam->tagDec.size); + ret = mbedtls_ccm_auth_decrypt(&ctx, + message->size, + aeadParam->nonce.data, + aeadParam->nonce.size, + aeadParam->aad.data, + aeadParam->aad.size, + message->data, + cipherText->data, + aeadParam->tagDec.data, + aeadParam->tagDec.size); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls aes ccm decrypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); @@ -300,6 +344,108 @@ static int32_t AesDecryptCcm(const struct HksBlob *key, const struct HksUsageSpe } #endif /* HKS_SUPPORT_AES_CCM */ +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING +static int32_t AesCtrCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) +{ + const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam); + mbedtls_cipher_context_t ctx; + mbedtls_cipher_init(&ctx); + + int32_t ret; + do { + const mbedtls_cipher_info_t *info = + mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_CTR); + + ret = mbedtls_cipher_setup(&ctx, info); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = %d", ret); + break; + } + + ret = mbedtls_cipher_setkey( + &ctx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = %d", ret); + break; + } + + size_t olen; + ret = mbedtls_cipher_crypt( + &ctx, cipherParam->iv.data, cipherParam->iv.size, message->data, message->size, cipherText->data, &olen); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = 0x%X", ret); + break; + } + cipherText->size = olen; + + mbedtls_cipher_free(&ctx); + return HKS_SUCCESS; + } while (0); + + mbedtls_cipher_free(&ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; +} +#endif + +#ifdef HKS_SUPPORT_AES_ECB_NOPADDING +static int32_t AesEcbNoPaddingCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) +{ + mbedtls_cipher_context_t ctx; + mbedtls_cipher_init(&ctx); + + int32_t ret; + do { + const mbedtls_cipher_info_t *info = + mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_ECB); + + ret = mbedtls_cipher_setup(&ctx, info); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = %d", ret); + break; + } + + ret = mbedtls_cipher_setkey( + &ctx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = %d", ret); + break; + } + + size_t olen; + ret = mbedtls_cipher_crypt(&ctx, NULL, 0, message->data, message->size, cipherText->data, &olen); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls failed ret = 0x%X", ret); + break; + } + cipherText->size = olen; + + mbedtls_cipher_free(&ctx); + return HKS_SUCCESS; + } while (0); + + mbedtls_cipher_free(&ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; +} +#endif + +static int32_t AesEcbCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) +{ + switch (usageSpec->padding) { +#ifdef HKS_SUPPORT_AES_ECB_NOPADDING + case HKS_PADDING_NONE: + return AesEcbNoPaddingCrypt(key, usageSpec, message, encrypt, cipherText); +#endif + case HKS_PADDING_PKCS7: + return HKS_ERROR_NOT_SUPPORTED; + default: + HKS_LOG_E("Unsupport padding! mode = 0x%X", usageSpec->padding); + return HKS_ERROR_INVALID_PADDING; + } +} + static int32_t CheckKeySize(const struct HksBlob *key) { if ((key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)) && (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192)) && @@ -330,6 +476,14 @@ int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpe #ifdef HKS_SUPPORT_AES_CCM case HKS_MODE_CCM: return AesEncryptCcm(key, usageSpec, message, cipherText, tagAead); +#endif +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING + case HKS_MODE_CTR: + return AesCtrCrypt(key, usageSpec, message, true, cipherText); +#endif +#if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) + case HKS_MODE_ECB: + return AesEcbCrypt(key, usageSpec, message, true, cipherText); #endif default: HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode); @@ -357,6 +511,14 @@ int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpe #ifdef HKS_SUPPORT_AES_CCM case HKS_MODE_CCM: return AesDecryptCcm(key, usageSpec, message, cipherText); +#endif +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING + case HKS_MODE_CTR: + return AesCtrCrypt(key, usageSpec, message, false, cipherText); +#endif +#if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) + case HKS_MODE_ECB: + return AesEcbCrypt(key, usageSpec, message, false, cipherText); #endif default: HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode); diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c index ecc290777b0b65c9c03d04eafff5fe8bb12deed3..26a019dfe016d5801a7828c16824f3624b0de7ce 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c @@ -35,6 +35,15 @@ const unsigned char g_hksRandomSeedCustom[] = { int32_t HksToMbedtlsDigestAlg(const uint32_t hksAlg, uint32_t *mbedtlsAlg) { switch (hksAlg) { + case HKS_DIGEST_MD5: + *mbedtlsAlg = MBEDTLS_MD_MD5; + break; + case HKS_DIGEST_SHA1: + *mbedtlsAlg = MBEDTLS_MD_SHA1; + break; + case HKS_DIGEST_SHA224: + *mbedtlsAlg = MBEDTLS_MD_SHA224; + break; case HKS_DIGEST_SHA256: *mbedtlsAlg = MBEDTLS_MD_SHA256; break; diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c new file mode 100755 index 0000000000000000000000000000000000000000..b6d941daa3be69aa6005b65d042bab1dcb4cc188 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2020-2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DH_C + +#include "hks_mbedtls_dh.h" + +#include + +#include "hks_log.h" +#include "hks_mbedtls_common.h" +#include "hks_mem.h" + +#define HKS_Dh_KEYPAIR_CNT 2 + +#if defined(HKS_SUPPORT_DH_GENERATE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) +static uint8_t ffdhe2048ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE2048_G_BIN; +static uint8_t ffdhe2048ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE2048_P_BIN; +static uint8_t ffdhe3072ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE3072_G_BIN; +static uint8_t ffdhe3072ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE3072_P_BIN; +static uint8_t ffdhe4096ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE4096_G_BIN; +static uint8_t ffdhe4096ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE4096_P_BIN; + +static int32_t GetDhParam(uint32_t keySize, struct HksBlob *P, struct HksBlob *G) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + P->data = ffdhe2048ParamP; + P->size = sizeof(ffdhe2048ParamP); + G->data = ffdhe2048ParamG; + G->size = sizeof(ffdhe2048ParamG); + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + P->data = ffdhe3072ParamP; + P->size = sizeof(ffdhe3072ParamP); + G->data = ffdhe3072ParamG; + G->size = sizeof(ffdhe3072ParamG); + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + P->data = ffdhe4096ParamP; + P->size = sizeof(ffdhe4096ParamP); + G->data = ffdhe4096ParamG; + G->size = sizeof(ffdhe4096ParamG); + return HKS_SUCCESS; + default: + return HKS_ERROR_INVALID_KEY_SIZE; + } +} +#endif + +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +static int32_t DhSaveKeyMaterial(const mbedtls_dhm_context *ctx, const uint32_t keySize, struct HksBlob *key) +{ + const uint32_t keyByteLen = HKS_KEY_BYTES(keySize); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + keyByteLen * HKS_Dh_KEYPAIR_CNT; + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + (void)memset_s(rawMaterial, rawMaterialLen, 0, rawMaterialLen); + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = mbedtls_mpi_size(&ctx->GX); + keyMaterial->priKeySize = mbedtls_mpi_size(&ctx->X); + + int32_t ret; + do { + uint32_t offset = sizeof(*keyMaterial); + ret = mbedtls_mpi_write_binary(&(ctx->GX), rawMaterial + offset, keyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_mpi_write_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + offset = offset + keyMaterial->pubKeySize; + ret = mbedtls_mpi_write_binary(&(ctx->X), rawMaterial + offset, keyMaterial->priKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_mpi_write_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + key->data = rawMaterial; + key->size = rawMaterialLen; + } while (0); + + return HKS_SUCCESS; +} + +int32_t HksMbedtlsDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + mbedtls_dhm_context ctx; + mbedtls_dhm_init(&ctx); + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctrDrbg; + int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); + if (ret != HKS_SUCCESS) { + mbedtls_dhm_free(&ctx); + return ret; + } + + do { + struct HksBlob paramP; + struct HksBlob paramG; + ret = GetDhParam(spec->keyLen, ¶mP, ¶mG); + if (ret != HKS_SUCCESS) { + break; + } + uint32_t keyLen = HKS_KEY_BYTES(spec->keyLen); + + if (mbedtls_mpi_read_binary(&ctx.P, paramP.data, paramP.size) != HKS_MBEDTLS_SUCCESS || + mbedtls_mpi_read_binary(&ctx.G, paramG.data, paramG.size) != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + ctx.len = keyLen; + + uint8_t *output = HksMalloc(keyLen); + ret = mbedtls_dhm_make_public(&ctx, keyLen, output, keyLen, mbedtls_ctr_drbg_random, &ctrDrbg); + if (ret != HKS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + } else { + ret = DhSaveKeyMaterial(&ctx, spec->keyLen, key); + } + HksFree(output); + } while (0); + + mbedtls_dhm_free(&ctx); + mbedtls_ctr_drbg_free(&ctrDrbg); + mbedtls_entropy_free(&entropy); + + return ret; +} +#endif + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return HKS_SUCCESS; +} +#endif + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +static int32_t DhKeyMaterialToCtx(const struct HksBlob *key, const bool needPrivateExponent, mbedtls_dhm_context *ctx) +{ + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + + int32_t ret; + do { + struct HksBlob paramP; + struct HksBlob paramG; + ret = GetDhParam(keyMaterial->keySize, ¶mP, ¶mG); + if (ret != HKS_SUCCESS) { + break; + } + + if (mbedtls_mpi_read_binary(&ctx->P, paramP.data, paramP.size) != HKS_MBEDTLS_SUCCESS || + mbedtls_mpi_read_binary(&ctx->G, paramG.data, paramG.size) != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + ctx->len = HKS_KEY_BYTES(keyMaterial->keySize); + + uint32_t offset = sizeof(struct KeyMaterialDh); + ret = mbedtls_mpi_read_binary(&ctx->GX, key->data + offset, keyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + HKS_LOG_E("mbedtls_mpi_read_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + if (needPrivateExponent) { + offset = offset + keyMaterial->pubKeySize; + ret = mbedtls_mpi_read_binary(&ctx->X, key->data + offset, keyMaterial->priKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + HKS_LOG_E("mbedtls_mpi_read_binary failed! mbedtls ret = 0x%X", ret); + break; + } + } + + ret = HKS_SUCCESS; + } while (0); + + return ret; +} + +int32_t HksMbedtlsDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey) +{ + if (HKS_KEY_BYTES(spec->keyLen) > sharedKey->size) { + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + + mbedtls_dhm_context ctx; + mbedtls_dhm_init(&ctx); + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctrDrbg; + int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); + if (ret != HKS_SUCCESS) { + mbedtls_dhm_free(&ctx); + return ret; + } + + do { + ret = DhKeyMaterialToCtx(nativeKey, true, &ctx); + if (ret != HKS_SUCCESS) { + break; + } + + ret = mbedtls_dhm_read_public(&ctx, pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_dhm_read_public failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + + size_t keyLen; + ret = + mbedtls_dhm_calc_secret(&ctx, sharedKey->data, sharedKey->size, &keyLen, mbedtls_ctr_drbg_random, &ctrDrbg); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_dhm_calc_secret failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + sharedKey->size = keyLen; + ret = HKS_SUCCESS; + } while (0); + + mbedtls_dhm_free(&ctx); + mbedtls_ctr_drbg_free(&ctrDrbg); + mbedtls_entropy_free(&entropy); + + return ret; +} +#endif + +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dsa.c new file mode 100755 index 0000000000000000000000000000000000000000..853ec525cd7c2c3517eb544577b7116f4f7f71a4 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dsa.c @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2020-2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DSA_C + +#include "hks_mbedtls_dsa.h" + +#include "hks_log.h" +#include "hks_mbedtls_common.h" +#include "hks_mem.h" + +int32_t HksMbedtlsDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + return HKS_ERROR_NOT_SUPPORTED; +} + +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c index 0b2e8ced2146dd0bfcb28f0270cfa21ea4b9baf1..58cd56391965d29c85b8739d40b8b596c548c541 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c @@ -40,7 +40,8 @@ static int32_t HksMbedtlsEccCheckKeySize(const uint32_t keySize) { - if ((keySize != HKS_ECC_KEY_SIZE_256) && (keySize != HKS_ECC_KEY_SIZE_384)) { + if ((keySize != HKS_ECC_KEY_SIZE_224) && (keySize != HKS_ECC_KEY_SIZE_256) && (keySize != HKS_ECC_KEY_SIZE_384) && + (keySize != HKS_ECC_KEY_SIZE_521)) { HKS_LOG_E("Invalid ecc keySize! keySize = 0x%X", keySize); return HKS_ERROR_INVALID_KEY_SIZE; } @@ -51,12 +52,18 @@ static int32_t HksMbedtlsEccCheckKeySize(const uint32_t keySize) int32_t GetEccGroupId(const uint32_t keyLen, mbedtls_ecp_group_id *grpId) { switch (keyLen) { + case HKS_ECC_KEY_SIZE_224: + *grpId = MBEDTLS_ECP_DP_SECP224R1; + break; case HKS_ECC_KEY_SIZE_256: *grpId = MBEDTLS_ECP_DP_SECP256R1; break; case HKS_ECC_KEY_SIZE_384: *grpId = MBEDTLS_ECP_DP_SECP384R1; break; + case HKS_ECC_KEY_SIZE_521: + *grpId = MBEDTLS_ECP_DP_SECP521R1; + break; default: HKS_LOG_E("Unsupported key length! keyLen: 0x%X", keyLen); return HKS_ERROR_INVALID_KEY_SIZE; @@ -66,7 +73,7 @@ int32_t GetEccGroupId(const uint32_t keyLen, mbedtls_ecp_group_id *grpId) static int32_t EccKeyMaterialXyzSizeCheck(const struct KeyMaterialEcc *keyMaterial) { - const uint32_t maxKeyByteLen = HKS_ECC_KEY_SIZE_384 / HKS_BITS_PER_BYTE; + const uint32_t maxKeyByteLen = HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_521); if ((keyMaterial->xSize > maxKeyByteLen) || (keyMaterial->ySize > maxKeyByteLen) || (keyMaterial->zSize > maxKeyByteLen)) { HKS_LOG_E("Invalid ecc keyMaterial! xSize = 0x%X, ySize = 0x%X, zSize = 0x%X", @@ -157,7 +164,7 @@ static int32_t EccSaveKeyMaterial(const mbedtls_ecp_keypair *ecp, const uint32_t keySize, struct HksBlob *key) { /* public exponent x and y, and private exponent, so need size is: key_size / 8 * 3 */ - const uint32_t keyByteLen = keySize / HKS_BITS_PER_BYTE; + const uint32_t keyByteLen = HKS_KEY_BYTES(keySize); const uint32_t rawMaterialLen = sizeof(struct KeyMaterialEcc) + keyByteLen * HKS_ECC_KEYPAIR_CNT; uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); if (rawMaterial == NULL) { diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c index 30552c328d241019c101546efadbeaabcc21baf7..0ecf04effbca2c80354d1c63874937a4a3f82b66 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c @@ -37,6 +37,7 @@ #include "hks_mbedtls_common.h" #include "hks_mbedtls_ecc.h" +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY static int32_t EccKeyMaterialToCtx(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, mbedtls_ecdh_context *ctx) { @@ -96,7 +97,7 @@ int32_t HksMbedtlsEcdh(const struct HksBlob *nativeKey, break; } - const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE; + const uint32_t keyByteLen = HKS_KEY_BYTES(spec->keyLen); ret = mbedtls_mpi_write_binary(&(ctx.z), sharedKey->data, keyByteLen); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls ecdh mpi write to sharedKey failed! mbedtls ret = 0x%X", ret); @@ -111,4 +112,5 @@ int32_t HksMbedtlsEcdh(const struct HksBlob *nativeKey, mbedtls_entropy_free(&entropy); return ret; } +#endif /* HKS_SUPPORT_ECDH_AGREE_KEY */ #endif /* HKS_SUPPORT_ECDH_C */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c index 9ca5c4496f9c2955d78bc99e0412ca7faf58bc0a..5bd9d04d19d7b18c35762425481ab08a2d61d9f4 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c @@ -32,12 +32,16 @@ #include #include +#include "hks_common_check.h" #include "hks_log.h" +#include "hks_mem.h" #include "hks_mbedtls_common.h" #include "hks_mbedtls_ecc.h" +#include "hks_mbedtls_hash.h" +#ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY /* users must ensure the input params not null */ -int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, +static int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { int32_t ret = EccKeyCheck(key); @@ -74,7 +78,8 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec } uint32_t mbedtlsAlg; - ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + ret = HksToMbedtlsDigestAlg(digest, &mbedtlsAlg); if (ret != HKS_SUCCESS) { break; } @@ -84,6 +89,7 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Ecc mbedtls sign fail! mbedtls ret = 0x%X", ret); (void)memset_s(signature->data, signature->size, 0, signature->size); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } } while (0); @@ -94,7 +100,7 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec } /* users must ensure the input params not null */ -int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, +static int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) { (void)usageSpec; @@ -129,10 +135,42 @@ int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSp message->data, message->size, signature->data, signature->size); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Ecc mbedtls verify fail! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } - }while (0); + } while (0); mbedtls_ecdsa_free(&ctx); return ret; } + +int32_t HksMbedtlsEcdsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature, bool isVerify) +{ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + int32_t ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + if (isVerify) { + ret = HksMbedtlsEcdsaVerify(key, usageSpec, &hash, signature); + } else { + ret = HksMbedtlsEcdsaSign(key, usageSpec, &hash, (struct HksBlob *)signature); + } + HKS_FREE_BLOB(hash); + + return ret; +} +#endif /* HKS_SUPPORT_ECDSA_SIGN_VERIFY */ #endif /* HKS_SUPPORT_ECDSA_C */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c index 3bca50465be0f56b7358135b513be5d83263e87b..e7c0dd228b614a4a1ac0efef3788643d332a3323 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c @@ -13,6 +13,8 @@ * limitations under the License. */ +#include "hks_mbedtls_engine.h" + #ifdef HKS_CONFIG_FILE #include HKS_CONFIG_FILE #else @@ -29,6 +31,8 @@ #include "hks_mbedtls_aes.h" #include "hks_mbedtls_bn.h" #include "hks_mbedtls_common.h" +#include "hks_mbedtls_dh.h" +#include "hks_mbedtls_dsa.h" #include "hks_mbedtls_ecc.h" #include "hks_mbedtls_ecdh.h" #include "hks_mbedtls_ecdsa.h" @@ -37,7 +41,10 @@ #include "hks_mbedtls_kdf.h" #include "hks_mbedtls_rsa.h" #include "hks_mbedtls_x25519.h" + +#ifndef _HARDWARE_ROOT_KEY_ #include "hks_rkc.h" +#endif #ifdef _CUT_AUTHENTICATE_ #undef HKS_SUPPORT_HASH_C @@ -48,9 +55,34 @@ #undef HKS_SUPPORT_KDF_PBKDF2 #endif +static int32_t EncryptCheckParam(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *cipherText) +{ + if (CheckBlob(key) != HKS_SUCCESS) { + HKS_LOG_E("Invalid param key!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + if (CheckBlob(message) != HKS_SUCCESS) { + HKS_LOG_E("Invalid param message!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + if (CheckBlob(cipherText) != HKS_SUCCESS) { + HKS_LOG_E("Invalid param cipherText!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + if (usageSpec == NULL) { + HKS_LOG_E("Invalid param usageSpec!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + return HKS_SUCCESS; +} + int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { + if (CheckBlob(key) != HKS_SUCCESS || CheckBlob(msg) != HKS_SUCCESS || CheckBlob(mac) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } #ifdef HKS_SUPPORT_HMAC_C return HksMbedtlsHmac(key, digestAlg, msg, mac); #else @@ -85,6 +117,10 @@ int32_t HksCryptoHalBnExpMod(struct HksBlob *x, const struct HksBlob *a, #ifndef _CUT_AUTHENTICATE_ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) { + if (spec == NULL || key == NULL) { + return HKS_ERROR_INVALID_ARGUMENT; + } + switch (spec->algType) { #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) case HKS_ALG_AES: @@ -96,6 +132,7 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k #endif #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) case HKS_ALG_ECC: + case HKS_ALG_ECDH: return HksMbedtlsEccGenerateKey(spec, key); #endif #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GENERATE_KEY) @@ -105,6 +142,18 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_GENERATE_KEY) case HKS_ALG_ED25519: return HksEd25519GenerateKey(key); +#endif +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) + case HKS_ALG_HMAC: + return HksMbedtlsHmacGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) + case HKS_ALG_DSA: + return HksMbedtlsDsaGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return HksMbedtlsDhGenerateKey(spec, key); #endif default: HKS_LOG_E("Unsupport alg type or macro is not on! type = 0x%X", spec->algType); @@ -162,6 +211,10 @@ int32_t HksCryptoHalGetPubKey(const struct HksBlob *keyIn, struct HksBlob *keyOu #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GET_PUBLIC_KEY) case HKS_ALG_X25519: return HksMbedtlsGetX25519PubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return HksMbedtlsGetDhPubKey(keyIn, keyOut); #endif default: HKS_LOG_E("Unsupport key mode or macro is not on! mode = 0x%X", key->keyAlg); @@ -185,8 +238,12 @@ int32_t HksCryptoHalDeriveKey(const struct HksBlob *mainKey, int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey) { + if (CheckBlob(nativeKey) != HKS_SUCCESS || CheckBlob(pubKey) != HKS_SUCCESS || spec == NULL || + CheckBlob(sharedKey) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (spec->algType) { -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY) case HKS_ALG_ECDH: return HksMbedtlsEcdh(nativeKey, pubKey, spec, sharedKey); #endif @@ -197,6 +254,10 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl #ifdef HKS_SUPPORT_ED25519_TO_X25519 case HKS_ALG_ED25519: return HksMbedtlsEd25519KeyAgreement(nativeKey, pubKey, sharedKey); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY) + case HKS_ALG_DH: + return HksMbedtlsDhAgreeKey(nativeKey, pubKey, spec, sharedKey); #endif default: HKS_LOG_E("Unsupport alg or macro is not on! alg = 0x%X", spec->algType); @@ -207,14 +268,18 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { + if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS || + CheckBlob(signature) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: return HksMbedtlsRsaSign(key, usageSpec, message, signature); #endif -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksMbedtlsEcdsaSign(key, usageSpec, message, signature); + return HksMbedtlsEcdsaSignVerify(key, usageSpec, message, signature, false); #endif #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) case HKS_ALG_ED25519: @@ -229,14 +294,18 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) { + if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS || + CheckBlob(signature) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: return HksMbedtlsRsaVerify(key, usageSpec, message, signature); #endif -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksMbedtlsEcdsaVerify(key, usageSpec, message, signature); + return HksMbedtlsEcdsaSignVerify(key, usageSpec, message, signature, true); #endif #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) case HKS_ALG_ED25519: @@ -274,6 +343,11 @@ int32_t HksCryptoHalFillRandom(struct HksBlob *randomData) int32_t HksCryptoHalEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead) { + int32_t ret = EncryptCheckParam(key, usageSpec, message, cipherText); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invalid params!"); + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #ifdef HKS_SUPPORT_AES_C case HKS_ALG_AES: @@ -292,6 +366,11 @@ int32_t HksCryptoHalEncrypt(const struct HksBlob *key, const struct HksUsageSpec int32_t HksCryptoHalDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText) { + int32_t ret = EncryptCheckParam(key, usageSpec, message, cipherText); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invalid params!"); + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #ifdef HKS_SUPPORT_AES_C case HKS_ALG_AES: diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c index 7678da9c0eabfd8690d7f8ac9579a67dbe44e831..909d95d60c88d84d51e7b8c4955df9128a2e8b34 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c @@ -27,6 +27,8 @@ #include "hks_mbedtls_hash.h" +#include +#include #include #include @@ -38,6 +40,15 @@ int32_t HksMbedtlsHash(uint32_t alg, const struct HksBlob *msg, struct HksBlob * { int32_t ret; switch (alg) { + case HKS_DIGEST_MD5: + ret = mbedtls_md5_ret(msg->data, msg->size, hash->data); /* 0 for MD5 */ + break; + case HKS_DIGEST_SHA1: + ret = mbedtls_sha1_ret(msg->data, msg->size, hash->data); /* 0 for SHA-1 */ + break; + case HKS_DIGEST_SHA224: + ret = mbedtls_sha256_ret(msg->data, msg->size, hash->data, 1); /* 0 for SHA-224 */ + break; case HKS_DIGEST_SHA256: ret = mbedtls_sha256_ret(msg->data, msg->size, hash->data, 0); /* 0 for SHA-256 */ break; diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c index 9914df8fba808fe25dc855cafe0b803ffb84c303..5f8f26eb833ff791445959de1a4018cd1bb35a0e 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c @@ -28,6 +28,48 @@ #include "hks_common_check.h" #include "hks_log.h" #include "hks_mbedtls_common.h" +#include "hks_mem.h" + +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY +int32_t HksMbedtlsHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + if (spec->keyLen % HKS_BITS_PER_BYTE != 0) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE; + + uint8_t *outKey = (uint8_t *)HksMalloc(keyByteLen); + if (outKey == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctrDrbg; + int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); + if (ret != HKS_SUCCESS) { + HKS_FREE_PTR(outKey); + return ret; + } + + do { + ret = mbedtls_ctr_drbg_random(&ctrDrbg, outKey, keyByteLen); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("Mbedtls ctr drbg random failed! mbedtls ret = 0x%X", ret); + (void)memset_s(outKey, keyByteLen, 0, keyByteLen); + HKS_FREE_PTR(outKey); + break; + } + + key->data = outKey; + key->size = keyByteLen; + } while (0); + + mbedtls_ctr_drbg_free(&ctrDrbg); + mbedtls_entropy_free(&entropy); + return ret; +} +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ int32_t HksMbedtlsHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c index d497b3d44029aee84af33649c3f0a14a09bd40da..9a9365f72429bc1c04a78f154d95ce6d3204bdc1 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c @@ -32,8 +32,10 @@ #include #include +#include "hks_common_check.h" #include "hks_log.h" #include "hks_mbedtls_common.h" +#include "hks_mbedtls_hash.h" #include "hks_mem.h" #define HKS_RSA_PUBLIC_EXPONENT 65537 @@ -42,6 +44,9 @@ static int32_t RsaCheckKeySize(const uint32_t keySize) { switch (keySize) { + case HKS_RSA_KEY_SIZE_512: + case HKS_RSA_KEY_SIZE_768: + case HKS_RSA_KEY_SIZE_1024: case HKS_RSA_KEY_SIZE_2048: case HKS_RSA_KEY_SIZE_3072: case HKS_RSA_KEY_SIZE_4096: @@ -60,7 +65,9 @@ static int32_t RsaKeyMaterialNedSizeCheck(const struct KeyMaterialRsa *keyMateri if ((keyMaterial->nSize > maxKeyByteLen) || (keyMaterial->eSize > maxKeyByteLen) || (keyMaterial->dSize > maxKeyByteLen)) { HKS_LOG_E("Invalid rsa keyMaterial! nSize = 0x%X, eSize = 0x%X, dSize = 0x%X", - keyMaterial->nSize, keyMaterial->eSize, keyMaterial->dSize); + keyMaterial->nSize, + keyMaterial->eSize, + keyMaterial->dSize); return HKS_ERROR_INVALID_ARGUMENT; } @@ -90,8 +97,7 @@ static int32_t RsaKeyCheck(const struct HksBlob *key) } #ifdef HKS_SUPPORT_RSA_GENERATE_KEY -static int32_t RsaSaveKeyMaterial(const mbedtls_rsa_context *ctx, - const uint32_t keySize, struct HksBlob *key) +static int32_t RsaSaveKeyMaterial(const mbedtls_rsa_context *ctx, const uint32_t keySize, struct HksBlob *key) { const uint32_t keyByteLen = keySize / HKS_BITS_PER_BYTE; const uint32_t rawMaterialLen = sizeof(struct KeyMaterialRsa) + keyByteLen * HKS_RSA_KEYPAIR_CNT; @@ -139,6 +145,7 @@ static int32_t RsaSaveKeyMaterial(const mbedtls_rsa_context *ctx, if (ret != HKS_MBEDTLS_SUCCESS) { (void)memset_s(rawMaterial, rawMaterialLen, 0, rawMaterialLen); HKS_FREE_PTR(rawMaterial); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } return ret; @@ -155,6 +162,7 @@ int32_t HksMbedtlsRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * mbedtls_entropy_context entropy; int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); if (ret != HKS_SUCCESS) { + mbedtls_rsa_free(&ctx); return ret; } @@ -162,6 +170,7 @@ int32_t HksMbedtlsRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * ret = mbedtls_rsa_gen_key(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, spec->keyLen, HKS_RSA_PUBLIC_EXPONENT); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls rsa generate key failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; break; } @@ -176,8 +185,7 @@ int32_t HksMbedtlsRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * #endif /* HKS_SUPPORT_RSA_GENERATE_KEY */ #if defined(HKS_SUPPORT_RSA_CRYPT) || defined(HKS_SUPPORT_RSA_SIGN_VERIFY) -static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, - const bool needPrivateExponent, mbedtls_rsa_context *ctx) +static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, const bool needPrivateExponent, mbedtls_rsa_context *ctx) { const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); @@ -229,11 +237,30 @@ static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, mbedtls_mpi_free(&n); mbedtls_mpi_free(&e); mbedtls_mpi_free(&d); + + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + } return ret; } #endif /* HKS_SUPPORT_RSA_CRYPT or HKS_SUPPORT_RSA_SIGN_VERIFY */ #ifdef HKS_SUPPORT_RSA_CRYPT +static int32_t HksToMbedtlsPadding(uint32_t hksPadding, int32_t *padding) +{ + switch (hksPadding) { + case HKS_PADDING_PKCS1_V1_5: + *padding = MBEDTLS_RSA_PKCS_V15; + break; + case HKS_PADDING_OAEP: + *padding = MBEDTLS_RSA_PKCS_V21; + break; + default: + return HKS_ERROR_NOT_SUPPORTED; + } + return HKS_SUCCESS; +} + int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) { @@ -242,12 +269,20 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec return ret; } - uint32_t mbedtlsAlg; - ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + int32_t padding; + ret = HksToMbedtlsPadding(usageSpec->padding, &padding); if (ret != HKS_SUCCESS) { return ret; } + uint32_t mbedtlsAlg; + if (padding == MBEDTLS_RSA_PKCS_V21) { + ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + if (ret != HKS_SUCCESS) { + return ret; + } + } + mbedtls_ctr_drbg_context ctrDrbg; mbedtls_entropy_context entropy; ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); @@ -256,7 +291,7 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec } mbedtls_rsa_context ctx; - mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, mbedtlsAlg); /* only support oaep padding */ + mbedtls_rsa_init(&ctx, padding, mbedtlsAlg); /* only support oaep padding */ do { ret = RsaKeyMaterialToCtx(key, !encrypt, &ctx); /* encrypt don't need private exponent (d) */ @@ -276,6 +311,7 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec if (ret != HKS_SUCCESS) { HKS_LOG_E("Mbedtls rsa crypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; break; } cipherText->size = (uint32_t)outlen; @@ -289,11 +325,31 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec #endif /* HKS_SUPPORT_RSA_CRYPT */ #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY -static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, - const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool sign, struct HksBlob *signature) +static int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding) +{ + switch (hksPadding) { + case HKS_PADDING_PKCS1_V1_5: + *padding = MBEDTLS_RSA_PKCS_V15; + break; + case HKS_PADDING_PSS: + *padding = MBEDTLS_RSA_PKCS_V21; + break; + default: + return HKS_ERROR_NOT_SUPPORTED; + } + return HKS_SUCCESS; +} +static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool sign, struct HksBlob *signature) { uint32_t mbedtlsAlg; - int32_t ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + int32_t ret = HksToMbedtlsDigestAlg(digest, &mbedtlsAlg); + if (ret != HKS_SUCCESS) { + return ret; + } + int32_t padding; + ret = HksToMbedtlsSignPadding(usageSpec->padding, &padding); if (ret != HKS_SUCCESS) { return ret; } @@ -306,7 +362,7 @@ static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, } mbedtls_rsa_context ctx; - mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, mbedtlsAlg); /* only support pss padding */ + mbedtls_rsa_init(&ctx, padding, mbedtlsAlg); do { ret = RsaKeyMaterialToCtx(key, sign, &ctx); /* sign need private exponent (d) */ @@ -315,14 +371,15 @@ static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, } if (sign) { - ret = mbedtls_rsa_pkcs1_sign(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, - MBEDTLS_RSA_PRIVATE, mbedtlsAlg, message->size, message->data, signature->data); + ret = mbedtls_rsa_pkcs1_sign(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, MBEDTLS_RSA_PRIVATE, + mbedtlsAlg, message->size, message->data, signature->data); } else { - ret = mbedtls_rsa_pkcs1_verify(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, - MBEDTLS_RSA_PUBLIC, mbedtlsAlg, message->size, message->data, signature->data); + ret = mbedtls_rsa_pkcs1_verify(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, MBEDTLS_RSA_PUBLIC, + mbedtlsAlg, message->size, message->data, signature->data); } - if (ret != HKS_SUCCESS) { + if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls rsa sign/verify failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; (void)memset_s(signature->data, signature->size, 0, signature->size); } } while (0); @@ -337,26 +394,64 @@ static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, return ret; } -int32_t HksMbedtlsRsaSign(const struct HksBlob *key, - const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) +int32_t HksMbedtlsRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature) { int32_t ret = RsaKeyCheck(key); if (ret != HKS_SUCCESS) { return ret; } - return HksMbedtlsRsaSignVerify(key, usageSpec, message, true, signature); /* true: is sign */ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + ret = HksMbedtlsRsaSignVerify(key, usageSpec, &hash, true, signature); /* true: is sign */ + HKS_FREE_BLOB(hash); + return ret; } -int32_t HksMbedtlsRsaVerify(const struct HksBlob *key, - const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) +int32_t HksMbedtlsRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) { int32_t ret = RsaKeyCheck(key); if (ret != HKS_SUCCESS) { return ret; } - return HksMbedtlsRsaSignVerify(key, usageSpec, message, false, (struct HksBlob *)signature); /* false: is verify */ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + ret = HksMbedtlsRsaSignVerify(key, usageSpec, &hash, false, (struct HksBlob *)signature); /* false: is verify */ + HKS_FREE_BLOB(hash); + return ret; } #endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn index 12dc2d00e3a3dccad18b4e802ab09aacc07397b3..1b516604d4ebccb1e67aeada33c1432c4bb5bb14 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn +++ b/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn @@ -35,12 +35,15 @@ ohos_static_library("libhuks_openssl_standard_static") { sources = [ "src/hks_openssl_aes.c", "src/hks_openssl_curve25519.c", + "src/hks_openssl_dh.c", + "src/hks_openssl_dsa.c", "src/hks_openssl_ecc.c", "src/hks_openssl_ed25519tox25519.c", "src/hks_openssl_engine.c", "src/hks_openssl_hash.c", "src/hks_openssl_hmac.c", "src/hks_openssl_kdf.c", + "src/hks_openssl_rsa.c", ] deps = [ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h index 65ddb8fa05e810bfbdb335c4a209d311efdf5050..aeffc098b67e7e362c26492d52eaf81d9ceaba8d 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h @@ -22,13 +22,21 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_AES_C +#ifdef HKS_SUPPORT_AES_GENERATE_KEY int32_t HksOpensslAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_AES_GENERATE_KEY */ +#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7) || \ + defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) || defined(HKS_SUPPORT_AES_CTR_NOPADDING) || \ + defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_GCM) int32_t HksOpensslAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead); int32_t HksOpensslAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText); +#endif /* HKS_SUPPORT_AES_CBC_NOPADDING */ +#endif /* HKS_SUPPORT_AES_C */ #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h new file mode 100755 index 0000000000000000000000000000000000000000..7b6b2f3d448fc51afa71353ce555afb0bf55386e --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_OPENSSL_DH_H +#define HKS_OPENSSL_DH_H + +#include "hks_crypto_hal.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HKS_SUPPORT_DH_C +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +int32_t HksOpensslDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksOpensslGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ +#endif /* HKS_SUPPORT_DH_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_OPENSSL_DH_H */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h new file mode 100755 index 0000000000000000000000000000000000000000..11e328f3a4edc6a7498ad31365257a5fbe4f0ee6 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_OPENSSL_DSA_H +#define HKS_OPENSSL_DSA_H + +#include "hks_crypto_hal.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DSA_KEYPAIR_CNT 5 + +#ifdef HKS_SUPPORT_DSA_C +#ifdef HKS_SUPPORT_DSA_GENERATE_KEY +int32_t HksOpensslDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DSA_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DSA_GET_PUBLIC_KEY +int32_t HksOpensslGetDsaPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +int32_t HksOpensslDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksOpensslDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_DSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_DSA_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_OPENSSL_DSA_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h index a5a2dff04691f5eac064434fda7289925809f3a7..b704d94e080d1106fec1110045ed46f5a661fd7d 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h @@ -22,21 +22,32 @@ extern "C" { #endif -#define ECC_KEYPAIR_CNT 3 +#define ECC_KEYPAIR_CNT 3 +#if defined(HKS_SUPPORT_ECC_GENERATE_KEY) || defined(HKS_SUPPORT_ECDH_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ECDSA_GENERATE_KEY) int32_t HksOpensslEccGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif +#if defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY) || defined(HKS_SUPPORT_ECDH_GET_PUBLIC_KEY) || \ + defined(HKS_SUPPORT_EDDSA_GET_PUBLIC_KEY) +int32_t HksOpensslGetEccPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_ECDH_AGREE_KEY */ +#ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY int32_t HksOpensslEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature); -int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksBlob *message, - const struct HksBlob *signature); +int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_ECDSA_SIGN_VERIFY */ #ifdef __cplusplus } #endif -#endif /* HKS_OPENSSL_ECC_H */ \ No newline at end of file +#endif /* HKS_OPENSSL_ECC_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h index 742b097b7d8e66d941f7fa5e9294408020aac75e..a8630c1fcb295163973c1c8478bda88d069425a0 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h @@ -36,7 +36,7 @@ extern "C" { #define HKS_OPENSSL_ERROR_LEN 128 #define BIT_NUM_OF_UINT8 8 -void HksLogOpensslError(); +void HksLogOpensslError(void); int32_t HksOpensslCheckBlob(const struct HksBlob *blob); diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h index acbcc6fc458f89e534427771a7e3c77c17d578ba..099f0af18b6a411ab67d4da0176105a532c2ecf1 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h @@ -22,15 +22,25 @@ extern "C" { #endif +#define HKS_DIGEST_SHA1_LEN 20 +#define HKS_DIGEST_SHA224_LEN 28 #define HKS_DIGEST_SHA256_LEN 32 #define HKS_DIGEST_SHA384_LEN 48 #define HKS_DIGEST_SHA512_LEN 64 -int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, - struct HksBlob *mac); +#ifdef HKS_SUPPORT_HMAC_C +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY +int32_t HksOpensslHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ + +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) +int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); +#endif /* HKS_SUPPORT_HMAC_SHA1 */ +#endif /* HKS_SUPPORT_HMAC_C */ #ifdef __cplusplus } #endif -#endif /* HKS_OPENSSL_HMAC_H */ \ No newline at end of file +#endif /* HKS_OPENSSL_HMAC_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h new file mode 100755 index 0000000000000000000000000000000000000000..1522e6e8102985724d947a53088e5ff38a777aac --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_OPENSSL_RSA_H +#define HKS_OPENSSL_RSA_H + +#include "hks_crypto_hal.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define HKS_RSA_KEYPAIR_CNT 3 + +#ifdef HKS_SUPPORT_RSA_C +#ifdef HKS_SUPPORT_RSA_GENERATE_KEY +int32_t HksOpensslRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_RSA_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_RSA_GET_PUBLIC_KEY +int32_t HksOpensslGetRsaPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_RSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_RSA_CRYPT +int32_t HksOpensslRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText); +#endif /* HKS_SUPPORT_RSA_CRYPT */ + +#ifdef HKS_SUPPORT_RSA_SIGN_VERIFY +int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_RSA_C */ + +#ifdef __cplusplus +} +#endif +#endif diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c index 037e95cb13b52b76630094561fc936f2de138c6f..4416e07ef77bd0df62c1a077f0b2500eeae68b92 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c @@ -13,6 +13,14 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_AES_C + #include "hks_openssl_aes.h" #include @@ -23,9 +31,11 @@ #include "hks_openssl_engine.h" #include "hks_type_inner.h" +#ifdef HKS_SUPPORT_AES_GENERATE_KEY static int32_t AesGenKeyCheckParam(const struct HksKeySpec *spec) { - if ((spec->keyLen != HKS_AES_KEY_SIZE_128) && (spec->keyLen != HKS_AES_KEY_SIZE_256)) { + if ((spec->keyLen != HKS_AES_KEY_SIZE_128) && (spec->keyLen != HKS_AES_KEY_SIZE_192) && + (spec->keyLen != HKS_AES_KEY_SIZE_256)) { HKS_LOG_E("Invlid aes key len %x!", spec->keyLen); return HKS_ERROR_INVALID_ARGUMENT; } @@ -65,6 +75,49 @@ int32_t HksOpensslAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob * } return ret; } +#endif + +static const EVP_CIPHER *GetCbcCipherType(uint32_t keySize) +{ + switch (keySize) { + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128): + return EVP_aes_128_cbc(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192): + return EVP_aes_192_cbc(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256): + return EVP_aes_256_cbc(); + default: + return NULL; + } +} + +static const EVP_CIPHER *GetCtrCipherType(uint32_t keySize) +{ + switch (keySize) { + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128): + return EVP_aes_128_ctr(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192): + return EVP_aes_192_ctr(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256): + return EVP_aes_256_ctr(); + default: + return NULL; + } +} + +static const EVP_CIPHER *GetEcbCipherType(uint32_t keySize) +{ + switch (keySize) { + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128): + return EVP_aes_128_ecb(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192): + return EVP_aes_192_ecb(); + case HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256): + return EVP_aes_256_ecb(); + default: + return NULL; + } +} static const EVP_CIPHER *GetGcmCipherType(uint32_t keySize) { @@ -80,6 +133,18 @@ static const EVP_CIPHER *GetGcmCipherType(uint32_t keySize) } } +static const EVP_CIPHER *GetCipherType(uint32_t keySize, uint32_t mode) +{ + if (mode == HKS_MODE_CBC) { + return GetCbcCipherType(keySize); + } else if (mode == HKS_MODE_CTR) { + return GetCtrCipherType(keySize); + } else if (mode == HKS_MODE_ECB) { + return GetEcbCipherType(keySize); + } + return NULL; +} + static const EVP_CIPHER *GetAeadCipherType(uint32_t keySize, uint32_t mode) { if (mode == HKS_MODE_GCM) { @@ -88,8 +153,9 @@ static const EVP_CIPHER *GetAeadCipherType(uint32_t keySize, uint32_t mode) return NULL; } -static int32_t OpensslAesAeadInit(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - bool isEncrypt, EVP_CIPHER_CTX **ctx) +#ifdef HKS_SUPPORT_AES_GCM +static int32_t OpensslAesAeadInit( + const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool isEncrypt, EVP_CIPHER_CTX **ctx) { int32_t ret; struct HksAeadParam *aeadParam = (struct HksAeadParam *)usageSpec->algParam; @@ -162,8 +228,8 @@ static int32_t OpensslAesAeadEncryptFinal(EVP_CIPHER_CTX *ctx, const struct HksU return HKS_SUCCESS; } -static int32_t OpensslAesAeadDecryptFinal(EVP_CIPHER_CTX *ctx, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, struct HksBlob *plainText) +static int32_t OpensslAesAeadDecryptFinal( + EVP_CIPHER_CTX *ctx, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *plainText) { int outLen = 0; struct HksAeadParam *aeadParam = (struct HksAeadParam *)usageSpec->algParam; @@ -179,8 +245,8 @@ static int32_t OpensslAesAeadDecryptFinal(EVP_CIPHER_CTX *ctx, const struct HksU } plainText->size = outLen; - if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, aeadParam->tagDec.size, aeadParam->tagDec.data) - != HKS_OPENSSL_SUCCESS) { + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, aeadParam->tagDec.size, aeadParam->tagDec.data) != + HKS_OPENSSL_SUCCESS) { HksLogOpensslError(); return HKS_ERROR_CRYPTO_ENGINE_ERROR; } @@ -192,6 +258,105 @@ static int32_t OpensslAesAeadDecryptFinal(EVP_CIPHER_CTX *ctx, const struct HksU return HKS_SUCCESS; } +#endif + +#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7) || \ + defined(HKS_SUPPORT_AES_CTR_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_NOPADDING) || \ + defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) +static int32_t OpensslAesCipherInit( + const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool isEncrypt, EVP_CIPHER_CTX **ctx) +{ + int32_t ret; + struct HksCipherParam *cipherParam = (struct HksCipherParam *)usageSpec->algParam; + + *ctx = EVP_CIPHER_CTX_new(); + if (*ctx == NULL) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + const EVP_CIPHER *cipher = GetCipherType(key->size, usageSpec->mode); + if (cipher == NULL) { + EVP_CIPHER_CTX_free(*ctx); + return HKS_ERROR_INVALID_ARGUMENT; + } + + if (isEncrypt) { + ret = EVP_EncryptInit_ex(*ctx, cipher, NULL, NULL, NULL); + } else { + ret = EVP_DecryptInit_ex(*ctx, cipher, NULL, NULL, NULL); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_CIPHER_CTX_free(*ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (isEncrypt) { + ret = EVP_EncryptInit_ex(*ctx, NULL, NULL, key->data, (cipherParam == NULL) ? NULL : cipherParam->iv.data); + } else { + ret = EVP_DecryptInit_ex(*ctx, NULL, NULL, key->data, (cipherParam == NULL) ? NULL : cipherParam->iv.data); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_CIPHER_CTX_free(*ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (usageSpec->padding == HKS_PADDING_PKCS7) { + ret = EVP_CIPHER_CTX_set_padding(*ctx, 1); + } else if (usageSpec->padding == HKS_PADDING_NONE) { + ret = EVP_CIPHER_CTX_set_padding(*ctx, 0); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_CIPHER_CTX_free(*ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + return HKS_SUCCESS; +} + +static int32_t OpensslAesCipherEncryptFinal( + EVP_CIPHER_CTX *ctx, const struct HksBlob *message, struct HksBlob *cipherText) +{ + int outLen = 0; + + if (EVP_EncryptUpdate(ctx, cipherText->data, &outLen, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + cipherText->size = outLen; + + if (EVP_EncryptFinal_ex(ctx, cipherText->data + outLen, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + cipherText->size += outLen; + + return HKS_SUCCESS; +} + +static int32_t OpensslAesCipherDecryptFinal( + EVP_CIPHER_CTX *ctx, const struct HksBlob *message, struct HksBlob *plainText) +{ + int outLen = 0; + + if (EVP_DecryptUpdate(ctx, plainText->data, &outLen, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + plainText->size = outLen; + + if (EVP_DecryptFinal_ex(ctx, plainText->data + outLen, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + plainText->size += outLen; + + return HKS_SUCCESS; +} +#endif int32_t HksOpensslAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead) @@ -201,6 +366,7 @@ int32_t HksOpensslAesEncrypt(const struct HksBlob *key, const struct HksUsageSpe int32_t ret; switch (usageSpec->mode) { +#ifdef HKS_SUPPORT_AES_GCM case HKS_MODE_GCM: ret = OpensslAesAeadInit(key, usageSpec, true, &ctx); if (ret != HKS_SUCCESS) { @@ -215,6 +381,27 @@ int32_t HksOpensslAesEncrypt(const struct HksBlob *key, const struct HksUsageSpe return ret; } break; +#endif +#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7) || \ + defined(HKS_SUPPORT_AES_CTR_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_NOPADDING) || \ + defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) + case HKS_MODE_CBC: + case HKS_MODE_CTR: + case HKS_MODE_ECB: + ret = OpensslAesCipherInit(key, usageSpec, true, &ctx); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("OpensslAesCipherInit fail, ret = %d", ret); + return ret; + } + + ret = OpensslAesCipherEncryptFinal(ctx, message, &tmpCipherText); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("OpensslAesCipherEncryptFinal fail, ret = %d", ret); + EVP_CIPHER_CTX_free(ctx); + return ret; + } + break; +#endif default: HKS_LOG_E("Unsupport aes mode! mode = 0x%x", usageSpec->mode); return HKS_ERROR_INVALID_ARGUMENT; @@ -247,6 +434,22 @@ int32_t HksOpensslAesDecrypt(const struct HksBlob *key, const struct HksUsageSpe return ret; } break; + case HKS_MODE_CBC: + case HKS_MODE_CTR: + case HKS_MODE_ECB: + ret = OpensslAesCipherInit(key, usageSpec, false, &ctx); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("OpensslAesCipherInit fail, ret = %d", ret); + return ret; + } + + ret = OpensslAesCipherDecryptFinal(ctx, message, &tmpPlainText); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("OpensslAesCipherDecryptFinal fail, ret = %d", ret); + EVP_CIPHER_CTX_free(ctx); + return ret; + } + break; default: HKS_LOG_E("Unsupport aes mode! mode = 0x%x", usageSpec->mode); return HKS_ERROR_INVALID_ARGUMENT; @@ -256,3 +459,4 @@ int32_t HksOpensslAesDecrypt(const struct HksBlob *key, const struct HksUsageSpe EVP_CIPHER_CTX_free(ctx); return ret; } +#endif diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c new file mode 100755 index 0000000000000000000000000000000000000000..e23be9c203a87ded41ff2c1a16fde06df8cb3435 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DH_C + +#include "hks_openssl_dh.h" + +#include +#include + +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_openssl_engine.h" +#include "hks_type_inner.h" + +static int32_t HksOpensslGetNid(uint32_t keySize, int *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return HKS_SUCCESS; + default: + HKS_LOG_E("invalid key size, keySize = %d", keySize); + return HKS_ERROR_INVALID_KEY_SIZE; + } +} + +static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + int32_t ret = HKS_SUCCESS; + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + if (key->size != sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize + keyMaterial->priKeySize) { + return NULL; + } + + int nid = 0; + ret = HksOpensslGetNid(keyMaterial->keySize, &nid); + if (ret != HKS_SUCCESS) { + return NULL; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + HksLogOpensslError(); + return NULL; + } + + uint32_t offset = sizeof(struct KeyMaterialDh); + BIGNUM *pubKey = BN_bin2bn(key->data + offset, keyMaterial->pubKeySize, NULL); + offset += keyMaterial->pubKeySize; + BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL); + + if (DH_set0_key(dh, pubKey, privKey) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DH_free(dh); + return NULL; + } + + return dh; +} + +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct HksBlob *key) +{ + const BIGNUM *pubKey = NULL; + const BIGNUM *privKey = NULL; + DH_get0_key(dh, &pubKey, &privKey); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + BN_num_bytes(pubKey) + BN_num_bytes(privKey); + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = BN_num_bytes(pubKey); + keyMaterial->priKeySize = BN_num_bytes(privKey); + keyMaterial->reserved = 0; + + uint32_t offset = sizeof(struct KeyMaterialDh); + BN_bn2bin(pubKey, rawMaterial + offset); + offset += keyMaterial->pubKeySize; + BN_bn2bin(privKey, rawMaterial + offset); + offset += keyMaterial->priKeySize; + + key->size = rawMaterialLen; + key->data = rawMaterial; + + return HKS_SUCCESS; +} + +int32_t HksOpensslDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + int32_t ret; + int nid = 0; + ret = HksOpensslGetNid(spec->keyLen, &nid); + if (ret != HKS_SUCCESS) { + return ret; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + if (DH_generate_key(dh) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DH_free(dh); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + ret = DhSaveKeyMaterial(dh, spec->keyLen, key); + + DH_free(dh); + + return ret; +} +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksOpensslGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey) +{ + int32_t ret; + if (HKS_KEY_BYTES(spec->keyLen) > sharedKey->size) { + return HKS_ERROR_INVALID_KEY_SIZE; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + DH *dh = InitDhStruct(nativeKey, true); + if (dh == NULL) { + BN_free(pub); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + uint8_t computeKey[DH_size(dh)]; + + if (DH_compute_key_padded(computeKey, pub, dh) <= 0) { + HksLogOpensslError(); + BN_free(pub); + DH_free(dh); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (HKS_KEY_BYTES(spec->keyLen) > (uint32_t)DH_size(dh)) { + ret = HKS_ERROR_INVALID_KEY_SIZE; + } else { + (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(spec->keyLen)); + sharedKey->size = DH_size(dh); + ret = HKS_SUCCESS; + } + + BN_free(pub); + DH_free(dh); + return ret; +} +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ + +#endif /* HKS_SUPPORT_DH_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c new file mode 100755 index 0000000000000000000000000000000000000000..d734664bd072a54f8f5effcf3b7f4f4adb9e0970 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c @@ -0,0 +1,383 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DSA_C + +#include "hks_openssl_dsa.h" + +#include +#include +#include + +#include "hks_common_check.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_openssl_engine.h" +#include "hks_type_inner.h" + +#define OPENSSL_KEY_BLOCK 8 +#define OPENSSL_DSA_MIN_KEY_LEN 64 +#define OPENSSL_DSA_KEY_LEN_DIVID (2048 / HKS_BITS_PER_BYTE) + +static uint32_t GetOpensslKeyBlocksLen(uint32_t keylen) +{ + return (keylen + OPENSSL_KEY_BLOCK - 1) / OPENSSL_KEY_BLOCK * OPENSSL_KEY_BLOCK; +} + +static DSA *InitDsaStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + DSA *dsa = DSA_new(); + if (dsa == NULL) { + return NULL; + } + + const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data); + uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + uint32_t offset = sizeof(*keyMaterial); + BIGNUM *x = NULL; + if (needPrivateExponent == true) { + if (keyMaterial->xSize == 0) { + DSA_free(dsa); + return NULL; + } else { + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize); + x = BN_bin2bn(buff, keyMaterial->xSize, NULL); + } + } + offset += keyMaterial->xSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->ySize); + BIGNUM *y = BN_bin2bn(buff, keyMaterial->ySize, NULL); + offset += keyMaterial->ySize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->pSize); + BIGNUM *p = BN_bin2bn(buff, keyMaterial->pSize, NULL); + offset += keyMaterial->pSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->qSize); + BIGNUM *q = BN_bin2bn(buff, keyMaterial->qSize, NULL); + offset += keyMaterial->qSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->gSize); + BIGNUM *g = BN_bin2bn(buff, keyMaterial->gSize, NULL); + + if (DSA_set0_key(dsa, y, x) != HKS_OPENSSL_SUCCESS || DSA_set0_pqg(dsa, p, q, g) != HKS_OPENSSL_SUCCESS) { + DSA_free(dsa); + return NULL; + } + return dsa; +} + +#ifdef HKS_SUPPORT_DSA_GENERATE_KEY +static void DsaGetKeyParamLen( + uint32_t keyLen, uint32_t *xlen, uint32_t *ylen, uint32_t *plen, uint32_t *qlen, uint32_t *glen) +{ + *xlen = (keyLen >= OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + *ylen = keyLen; + *plen = keyLen; + *qlen = (keyLen >= OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + *glen = keyLen; +} + +static uint32_t DsaCalculateMaterialLen(uint32_t keySize, uint32_t *dsaKeyLen) +{ + uint32_t opensslKeyByteLen = HKS_KEY_BYTES(keySize); + if (opensslKeyByteLen < OPENSSL_DSA_MIN_KEY_LEN) { + opensslKeyByteLen = OPENSSL_DSA_MIN_KEY_LEN; + } + + opensslKeyByteLen = GetOpensslKeyBlocksLen(opensslKeyByteLen); + + uint32_t xlen = (opensslKeyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + uint32_t ylen = opensslKeyByteLen; + uint32_t plen = opensslKeyByteLen; + uint32_t qlen = (opensslKeyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + uint32_t glen = opensslKeyByteLen; + DsaGetKeyParamLen(opensslKeyByteLen, &xlen, &ylen, &plen, &qlen, &glen); + + if (dsaKeyLen != NULL) { + *dsaKeyLen = opensslKeyByteLen; + } + + return sizeof(struct KeyMaterialDsa) + xlen + ylen + plen + qlen + glen; +} + +static int32_t DsaKeyMaterialParam(uint8_t *rawMaterial, const DSA *dsa, uint32_t keyLen) +{ + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = keyLen * HKS_BITS_PER_BYTE; + DsaGetKeyParamLen(keyLen, + &keyMaterial->xSize, + &keyMaterial->ySize, + &keyMaterial->pSize, + &keyMaterial->qSize, + &keyMaterial->gSize); + return HKS_SUCCESS; +} + +static int32_t DsaKeyMaterialData(uint8_t *rawMaterial, const DSA *dsa) +{ + int32_t ret; + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)rawMaterial; + const BIGNUM *x = DSA_get0_priv_key(dsa); + const BIGNUM *y = DSA_get0_pub_key(dsa); + const BIGNUM *p = DSA_get0_p(dsa); + const BIGNUM *q = DSA_get0_q(dsa); + const BIGNUM *g = DSA_get0_g(dsa); + + int32_t offset = sizeof(struct KeyMaterialDsa); + ret = BN_bn2bin(x, rawMaterial + offset + (keyMaterial->xSize - BN_num_bytes(x))); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + offset += keyMaterial->xSize; + ret = BN_bn2bin(y, rawMaterial + offset + (keyMaterial->ySize - BN_num_bytes(y))); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + offset += keyMaterial->ySize; + ret = BN_bn2bin(p, rawMaterial + offset + (keyMaterial->pSize - BN_num_bytes(p))); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + offset += keyMaterial->pSize; + ret = BN_bn2bin(q, rawMaterial + offset + (keyMaterial->qSize - BN_num_bytes(q))); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + offset += keyMaterial->qSize; + ret = BN_bn2bin(g, rawMaterial + offset + (keyMaterial->gSize - BN_num_bytes(g))); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + return HKS_SUCCESS; +} + +static int32_t DsaSaveKeyMaterial(const DSA *dsa, const uint32_t keySize, uint8_t **output, uint32_t *outputSize) +{ + uint32_t keyLen; + uint32_t rawMaterialLen = DsaCalculateMaterialLen(keySize, &keyLen); + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + HKS_LOG_E("malloc buffer failed!"); + return HKS_ERROR_MALLOC_FAIL; + } + + if (DsaKeyMaterialParam(rawMaterial, dsa, keyLen) != HKS_SUCCESS) { + HksFree(rawMaterial); + return HKS_FAILURE; + } + if (DsaKeyMaterialData(rawMaterial, dsa) != HKS_SUCCESS) { + HksFree(rawMaterial); + return HKS_FAILURE; + } + + *output = rawMaterial; + *outputSize = rawMaterialLen; + return HKS_SUCCESS; +} + +int32_t HksOpensslDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + int32_t ret; + if ((spec->keyLen == 0) || (spec->keyLen % HKS_BITS_PER_BYTE != 0)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + DSA *dsa = DSA_new(); + if (dsa == NULL) { + HKS_LOG_E("DSA structure is NULL."); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + do { + ret = DSA_generate_parameters_ex(dsa, spec->keyLen, NULL, 0, NULL, NULL, NULL); + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + + ret = DSA_generate_key(dsa); + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + + ret = DsaSaveKeyMaterial(dsa, spec->keyLen, &key->data, &key->size); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("save dsa key material failed! ret=0x%x", ret); + break; + } + } while (0); + + if (dsa != NULL) { + DSA_free(dsa); + } + + return ret; +} +#endif + +#ifdef HKS_SUPPORT_DSA_GET_PUBLIC_KEY +int32_t HksOpensslGetDsaPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)input->data; + + output->size = sizeof(struct KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + + keyMaterial->gSize; + + struct KeyMaterialDsa *publickeyMaterial = (struct KeyMaterialDsa *)output->data; + publickeyMaterial->keyAlg = keyMaterial->keyAlg; + publickeyMaterial->keySize = keyMaterial->keySize; + publickeyMaterial->xSize = 0; + publickeyMaterial->ySize = keyMaterial->ySize; + publickeyMaterial->pSize = keyMaterial->pSize; + publickeyMaterial->qSize = keyMaterial->qSize; + publickeyMaterial->gSize = keyMaterial->gSize; + + memcpy_s(output->data + sizeof(struct KeyMaterialDsa) + publickeyMaterial->xSize, + output->size - (sizeof(struct KeyMaterialDsa) + publickeyMaterial->xSize), + input->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize, + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize); + + return HKS_SUCCESS; +} +#endif + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +static EVP_MD_CTX *InitDSAMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) +{ + int32_t ret; + + DSA *dsa = InitDsaStruct(key, signing); + if (dsa == NULL) { + HKS_LOG_E("initialize dsa key failed"); + return NULL; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + HksLogOpensslError(); + DSA_free(dsa); + return NULL; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DSA_free(dsa); + EVP_PKEY_free(pkey); + return NULL; + } + + EVP_MD_CTX *ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + return NULL; + } + + if (signing) { + ret = EVP_DigestSignInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } else { + ret = EVP_DigestVerifyInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(ctx); + return NULL; + } + EVP_PKEY_free(pkey); + + return ctx; +} + +int32_t HksOpensslDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitDSAMdCtx(key, usageSpec, true); + if (ctx == NULL) { + HKS_LOG_E("initialize ecc md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + size_t outLen = 0; + if (EVP_DigestSignFinal(ctx, NULL, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (outLen > signature->size) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + signature->size = outLen; + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} + +int32_t HksOpensslDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitDSAMdCtx(key, usageSpec, false); + if (ctx == NULL) { + HKS_LOG_E("initialize ecc md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} +#endif +#endif diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c index 22840b9821c84c8033800ef57c7e7767e6a25f0c..8b9d51c458d5c872df8edc434092007c3c60a299 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c @@ -13,6 +13,13 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_ECC_C #include "hks_openssl_ecc.h" #include @@ -25,17 +32,42 @@ #include "hks_mem.h" #include "hks_openssl_engine.h" -int32_t HksOpensslEccCheckKeyLen(uint32_t keyLen) +static int32_t HksOpensslEccCheckKeyLen(uint32_t keyLen) { - if ((keyLen != HKS_ECC_KEY_SIZE_256) && (keyLen != HKS_ECC_KEY_SIZE_384)) { + if ((keyLen != HKS_ECC_KEY_SIZE_224) && (keyLen != HKS_ECC_KEY_SIZE_256) && (keyLen != HKS_ECC_KEY_SIZE_384) && + (keyLen != HKS_ECC_KEY_SIZE_521)) { HKS_LOG_E("invalid param keyLen(0x%x)!", keyLen); return HKS_ERROR_INVALID_ARGUMENT; } return HKS_SUCCESS; } -static int32_t TransEccKeyToKeyBlob(const EC_KEY *eccKey, struct KeyMaterialEcc *keyMaterial, BIGNUM *pubX, - BIGNUM *pubY, uint8_t *rawMaterial) +static int32_t HksOpensslGetCurveId(uint32_t keyLen, int *nid) +{ + switch (keyLen) { + case HKS_ECC_KEY_SIZE_224: + *nid = NID_secp224r1; + break; + case HKS_ECC_KEY_SIZE_256: + *nid = NID_X9_62_prime256v1; + break; + case HKS_ECC_KEY_SIZE_384: + *nid = NID_secp384r1; + break; + case HKS_ECC_KEY_SIZE_521: + *nid = NID_secp521r1; + break; + default: + HKS_LOG_E("invalid key size."); + return HKS_ERROR_INVALID_AE_TAG; + } + + return HKS_SUCCESS; +} + +#ifdef HKS_SUPPORT_ECC_GENERATE_KEY +static int32_t TransEccKeyToKeyBlob( + const EC_KEY *eccKey, const struct KeyMaterialEcc *keyMaterial, BIGNUM *pubX, BIGNUM *pubY, uint8_t *rawMaterial) { const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); int retCode = EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL); @@ -45,26 +77,23 @@ static int32_t TransEccKeyToKeyBlob(const EC_KEY *eccKey, struct KeyMaterialEcc } const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); - keyMaterial->xSize = BN_num_bytes(pubX); - keyMaterial->ySize = BN_num_bytes(pubY); - keyMaterial->zSize = BN_num_bytes(priv); uint32_t offset = sizeof(struct KeyMaterialEcc); - retCode = BN_bn2bin(pubX, rawMaterial + offset); + retCode = BN_bn2binpad(pubX, rawMaterial + offset, keyMaterial->xSize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; } offset += keyMaterial->xSize; - retCode = BN_bn2bin(pubY, rawMaterial + offset); + retCode = BN_bn2binpad(pubY, rawMaterial + offset, keyMaterial->ySize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; } offset += keyMaterial->ySize; - retCode = BN_bn2bin(priv, rawMaterial + offset); + retCode = BN_bn2binpad(priv, rawMaterial + offset, keyMaterial->zSize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; @@ -73,11 +102,10 @@ static int32_t TransEccKeyToKeyBlob(const EC_KEY *eccKey, struct KeyMaterialEcc return HKS_SUCCESS; } -static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keySize, uint8_t **output, - uint32_t *outputSize) +static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keySize, uint8_t **output, uint32_t *outputSize) { /* public exponent x and y, and private exponent, so need size is: keySize / 8 * 3 */ - uint32_t rawMaterialLen = sizeof(struct KeyMaterialEcc) + keySize / BIT_NUM_OF_UINT8 * ECC_KEYPAIR_CNT; + uint32_t rawMaterialLen = sizeof(struct KeyMaterialEcc) + HKS_KEY_BYTES(keySize) * ECC_KEYPAIR_CNT; uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); if (rawMaterial == NULL) { HKS_LOG_E("malloc buffer failed!"); @@ -90,6 +118,9 @@ static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keySize, struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)rawMaterial; keyMaterial->keyAlg = HKS_ALG_ECC; keyMaterial->keySize = keySize; + keyMaterial->xSize = HKS_KEY_BYTES(keySize); + keyMaterial->ySize = HKS_KEY_BYTES(keySize); + keyMaterial->zSize = HKS_KEY_BYTES(keySize); BIGNUM *pubX = BN_new(); BIGNUM *pubY = BN_new(); @@ -133,7 +164,13 @@ int32_t HksOpensslEccGenerateKey(const struct HksKeySpec *spec, struct HksBlob * EC_KEY *eccKey = NULL; int32_t ret = HKS_FAILURE; do { - eccKey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); + int curveId; + ret = HksOpensslGetCurveId(spec->keyLen, &curveId); + if (ret != HKS_SUCCESS) { + break; + } + + eccKey = EC_KEY_new_by_curve_name(curveId); if (eccKey == NULL) { HksLogOpensslError(); break; @@ -157,9 +194,33 @@ int32_t HksOpensslEccGenerateKey(const struct HksKeySpec *spec, struct HksBlob * return ret; } +#endif -static int GetEccModules(const uint8_t *key, uint32_t *keySize, uint32_t *publicXSize, - uint32_t *publicYSize, uint32_t *privateXSize) +#ifdef HKS_SUPPORT_ECC_GET_PUBLIC_KEY +int32_t HksOpensslGetEccPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)input->data; + + output->size = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + + struct KeyMaterialEcc *publickeyMaterial = (struct KeyMaterialEcc *)output->data; + publickeyMaterial->keyAlg = keyMaterial->keyAlg; + publickeyMaterial->keySize = keyMaterial->keySize; + publickeyMaterial->xSize = keyMaterial->xSize; + publickeyMaterial->ySize = keyMaterial->ySize; + publickeyMaterial->zSize = 0; + + memcpy_s(output->data + sizeof(struct KeyMaterialEcc), + output->size - sizeof(struct KeyMaterialEcc), + input->data + sizeof(struct KeyMaterialEcc), + keyMaterial->xSize + keyMaterial->ySize); + + return HKS_SUCCESS; +} +#endif + +static int GetEccModules( + const uint8_t *key, uint32_t *keySize, uint32_t *publicXSize, uint32_t *publicYSize, uint32_t *privateXSize) { struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)key; *keySize = keyMaterial->keySize; @@ -233,7 +294,13 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool private) return NULL; } - EC_KEY *eccKey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); + int nid; + if (HksOpensslGetCurveId(keySize, &nid) != HKS_SUCCESS) { + HKS_LOG_E("get curve id failed"); + return NULL; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); if (eccKey == NULL) { HksLogOpensslError(); return NULL; @@ -246,8 +313,7 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool private) } if (private) { - BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, - privateSize, NULL); + BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, privateSize, NULL); if (pri == NULL || EC_KEY_set_private_key(eccKey, pri) <= 0) { HKS_LOG_E("build ecc key failed"); BN_free(pri); @@ -260,7 +326,7 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool private) return eccKey; } -int32_t GetEvpKey(const struct HksBlob *keyBlob, EVP_PKEY *key, bool private) +static int32_t GetEvpKey(const struct HksBlob *keyBlob, EVP_PKEY *key, bool private) { EC_KEY *eccKey = EccInitKey(keyBlob, private); if (eccKey == NULL) { @@ -276,7 +342,7 @@ int32_t GetEvpKey(const struct HksBlob *keyBlob, EVP_PKEY *key, bool private) return HKS_SUCCESS; } -int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) +static int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) { int32_t ret = GetEvpKey(nativeKey, key, true); if (ret != HKS_SUCCESS) { @@ -286,7 +352,7 @@ int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) return ret; } -int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) +static int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) { int32_t ret = GetEvpKey(pubKey, key, false); if (ret != HKS_SUCCESS) { @@ -296,7 +362,7 @@ int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) return ret; } -int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) +static int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) { size_t tmpSharedKeySize = (size_t)sharedKey->size; if (EVP_PKEY_derive_init(ctx) != 1) { @@ -312,23 +378,20 @@ int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedK return HKS_FAILURE; } - uint8_t *buffer = (uint8_t *)HksMalloc(tmpSharedKeySize); - if (buffer == NULL) { - HKS_LOG_E("malloc size %u failed", tmpSharedKeySize); - return HKS_ERROR_MALLOC_FAIL; + if (tmpSharedKeySize > sharedKey->size) { + return HKS_ERROR_BUFFER_TOO_SMALL; } - if (EVP_PKEY_derive(ctx, buffer, &tmpSharedKeySize) != 1) { + + if (EVP_PKEY_derive(ctx, sharedKey->data, &tmpSharedKeySize) != 1) { HksLogOpensslError(); - HksFree(buffer); return HKS_FAILURE; } - sharedKey->size = (uint32_t)tmpSharedKeySize; - sharedKey->data = buffer; + sharedKey->size = tmpSharedKeySize; + return HKS_SUCCESS; } -int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, - struct HksBlob *sharedKey) +static int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) { int32_t res = HKS_FAILURE; EVP_PKEY *pKey = EVP_PKEY_new(); @@ -378,6 +441,7 @@ int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubK return res; } +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey) { @@ -393,10 +457,11 @@ int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct Hks return ret; } +#endif -static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, bool sign) +static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign) { - const EVP_MD *md = EVP_sha256(); + const EVP_MD *md = GetOpensslAlg(digest); EC_KEY *eccKey = EccInitKey(mainKey, sign); if (eccKey == NULL) { @@ -444,26 +509,27 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, bool sign) return ctx; } -int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksBlob *message, - const struct HksBlob *signature) +#ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY +int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitEccMdCtx(key, false); + EVP_MD_CTX *ctx = InitEccMdCtx(key, usageSpec->digest, false); if (ctx == NULL) { HKS_LOG_E("initialize ecc md context failed"); - return HKS_FAILURE; + return HKS_ERROR_INVALID_KEY_INFO; } if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } int32_t ret = EVP_DigestVerifyFinal(ctx, signature->data, signature->size); if (ret <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } EVP_MD_CTX_free(ctx); @@ -473,32 +539,40 @@ int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksBlob *m int32_t HksOpensslEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitEccMdCtx(key, true); + EVP_MD_CTX *ctx = InitEccMdCtx(key, usageSpec->digest, true); if (ctx == NULL) { HKS_LOG_E("initialize ecc md context failed"); - return HKS_FAILURE; + return HKS_ERROR_INVALID_KEY_INFO; } if (EVP_DigestSignUpdate(ctx, message->data, message->size) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - size_t req = 0; + size_t outLen = 0; - if (EVP_DigestSignFinal(ctx, NULL, &req) <= 0) { + if (EVP_DigestSignFinal(ctx, NULL, &outLen) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - if (EVP_DigestSignFinal(ctx, signature->data, &req) <= 0) { + if (outLen > signature->size) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) <= 0) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - signature->size = req; + signature->size = outLen; EVP_MD_CTX_free(ctx); return HKS_SUCCESS; } +#endif +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c index b0979cf49a9aff730b75e243e5fa05655d739661..15394af9cc6a484cecde1013d4674b9cbfca1b61 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c @@ -13,6 +13,12 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + #include "hks_openssl_engine.h" #include @@ -26,14 +32,17 @@ #include "hks_mem.h" #include "hks_openssl_aes.h" #include "hks_openssl_curve25519.h" +#include "hks_openssl_dh.h" +#include "hks_openssl_dsa.h" #include "hks_openssl_ecc.h" #include "hks_openssl_ed25519tox25519.h" #include "hks_openssl_hash.h" #include "hks_openssl_hmac.h" #include "hks_openssl_kdf.h" +#include "hks_openssl_rsa.h" #include "hks_type_inner.h" -void HksLogOpensslError() +void HksLogOpensslError(void) { char szErr[HKS_OPENSSL_ERROR_LEN] = {0}; unsigned long errCode; @@ -84,8 +93,8 @@ static int32_t SignVerifyCheckParam(const struct HksBlob *key, const struct HksU return HKS_SUCCESS; } -static int32_t DeriveKeyCheckParam(const struct HksBlob *mainKey, const struct HksKeySpec *derivationSpec, - struct HksBlob *derivedKey) +static int32_t DeriveKeyCheckParam( + const struct HksBlob *mainKey, const struct HksKeySpec *derivationSpec, struct HksBlob *derivedKey) { if (HksOpensslCheckBlob(mainKey) != HKS_SUCCESS) { HKS_LOG_E("Invalid mainKey params!"); @@ -155,6 +164,12 @@ static int32_t DecryptCheckParam(const struct HksBlob *key, const struct HksUsag const EVP_MD *GetOpensslAlg(uint32_t alg) { switch (alg) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); case HKS_DIGEST_SHA256: return EVP_sha256(); case HKS_DIGEST_SHA384: @@ -189,7 +204,7 @@ int32_t HksCryptoHalFillRandom(struct HksBlob *randomData) HKS_LOG_E("fill random failed, size %x", randomData->size); return HKS_ERROR_UNKNOWN_ERROR; } - HKS_LOG_E("generate random success"); + HKS_LOG_D("generate random success"); return HKS_SUCCESS; } @@ -202,6 +217,22 @@ int32_t HksCryptoHalGetPubKey(const struct HksBlob *keyIn, struct HksBlob *keyOu struct KeyMaterialRsa *key = (struct KeyMaterialRsa *)(keyIn->data); switch (key->keyAlg) { +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GET_PUBLIC_KEY) + case HKS_ALG_DSA: + return HksOpensslGetDsaPubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY) + case HKS_ALG_RSA: + return HksOpensslGetRsaPubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY) + case HKS_ALG_ECC: + return HksOpensslGetEccPubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return HksOpensslGetDhPubKey(keyIn, keyOut); +#endif case HKS_ALG_ED25519: return HksOpensslGetEd25519PubKey(keyIn, keyOut); default: @@ -216,10 +247,18 @@ int32_t HksCryptoHalGetMainKey(const struct HksBlob *message, struct HksBlob *ma return 0; } -int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, - struct HksBlob *mac) +int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { +#if defined(HKS_SUPPORT_HMAC_C) +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) return HksOpensslHmac(key, digestAlg, msg, mac); +#else + return HKS_ERROR_INVALID_ARGUMENT; +#endif +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif /* HKS_SUPPORT_HMAC_C */ } int32_t HksCryptoHalHash(uint32_t alg, const struct HksBlob *msg, struct HksBlob *hash) @@ -236,16 +275,16 @@ static void BnFreeParams(struct HksBnExpModParams *bnParams) BN_CTX_free(bnParams->ctx); } -static int32_t BnBuildParams(struct HksBnExpModParams *bnParams, const struct HksBlob *a, - const struct HksBlob *e, const struct HksBlob *n) +static int32_t BnBuildParams( + struct HksBnExpModParams *bnParams, const struct HksBlob *a, const struct HksBlob *e, const struct HksBlob *n) { bnParams->ctx = BN_CTX_new(); bnParams->bnX = BN_new(); bnParams->bnA = BN_bin2bn(a->data, a->size, NULL); bnParams->bnE = BN_bin2bn(e->data, e->size, NULL); bnParams->bnN = BN_bin2bn(n->data, n->size, NULL); - if ((bnParams->ctx == NULL) || (bnParams->bnX == NULL) || (bnParams->bnA == NULL) || - (bnParams->bnE == NULL) || (bnParams->bnN == NULL)) { + if ((bnParams->ctx == NULL) || (bnParams->bnX == NULL) || (bnParams->bnA == NULL) || (bnParams->bnE == NULL) || + (bnParams->bnN == NULL)) { BnFreeParams(bnParams); return HKS_ERROR_CRYPTO_ENGINE_ERROR; } @@ -290,8 +329,8 @@ static int32_t BnExpModExport(BIGNUM *bnX, struct HksBlob *x) return ret; } -int32_t HksCryptoHalBnExpMod(struct HksBlob *x, const struct HksBlob *a, - const struct HksBlob *e, const struct HksBlob *n) +int32_t HksCryptoHalBnExpMod( + struct HksBlob *x, const struct HksBlob *a, const struct HksBlob *e, const struct HksBlob *n) { struct HksBnExpModParams bnParams; (void)memset_s(&bnParams, sizeof(bnParams), 0, sizeof(bnParams)); @@ -337,13 +376,36 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k HKS_LOG_I("generate key type %x", spec->algType); switch (spec->algType) { +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) case HKS_ALG_ECC: + case HKS_ALG_ECDH: return HksOpensslEccGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) case HKS_ALG_AES: return HksOpensslAesGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) case HKS_ALG_X25519: case HKS_ALG_ED25519: return HksOpensslCurve25519GenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + case HKS_ALG_RSA: + return HksOpensslRsaGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) + case HKS_ALG_HMAC: + return HksOpensslHmacGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) + case HKS_ALG_DSA: + return HksOpensslDsaGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return HksOpensslDhGenerateKey(spec, key); +#endif default: HKS_LOG_E("Unsupport algType now!"); return HKS_ERROR_INVALID_ARGUMENT; @@ -360,8 +422,14 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl } switch (spec->algType) { +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY) case HKS_ALG_ECDH: return HksOpensslEcdhAgreeKey(nativeKey, pubKey, spec, sharedKey); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY) + case HKS_ALG_DH: + return HksOpensslDhAgreeKey(nativeKey, pubKey, spec, sharedKey); +#endif case HKS_ALG_X25519: return HksOpensslX25519AgreeKey(nativeKey, pubKey, sharedKey); case HKS_ALG_ED25519: @@ -372,8 +440,8 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl } } -int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, struct HksBlob *signature) +int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, + struct HksBlob *signature) { int32_t ret = SignVerifyCheckParam(key, usageSpec, message, signature); if (ret != HKS_SUCCESS) { @@ -382,8 +450,18 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u } switch (usageSpec->algType) { +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: return HksOpensslEcdsaSign(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) + case HKS_ALG_RSA: + return HksOpensslRsaSign(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HksOpensslDsaSign(key, usageSpec, message, signature); +#endif case HKS_ALG_ED25519: return HksOpensslEd25519Sign(key, message, signature); default: @@ -402,8 +480,18 @@ int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec } switch (usageSpec->algType) { +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksOpensslEcdsaVerify(key, message, signature); + return HksOpensslEcdsaVerify(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) + case HKS_ALG_RSA: + return HksOpensslRsaVerify(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HksOpensslDsaVerify(key, usageSpec, message, signature); +#endif case HKS_ALG_ED25519: return HksOpensslEd25519Verify(key, message, signature); default: @@ -412,8 +500,8 @@ int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec } } -int32_t HksCryptoHalDeriveKey(const struct HksBlob *masterKey, const struct HksKeySpec *derivationSpec, - struct HksBlob *derivedKey) +int32_t HksCryptoHalDeriveKey( + const struct HksBlob *masterKey, const struct HksKeySpec *derivationSpec, struct HksBlob *derivedKey) { int32_t ret = DeriveKeyCheckParam(masterKey, derivationSpec, derivedKey); if (ret != HKS_SUCCESS) { @@ -442,8 +530,14 @@ int32_t HksCryptoHalEncrypt(const struct HksBlob *key, const struct HksUsageSpec } switch (usageSpec->algType) { +#ifdef HKS_SUPPORT_AES_C case HKS_ALG_AES: return HksOpensslAesEncrypt(key, usageSpec, message, cipherText, tagAead); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT) + case HKS_ALG_RSA: + return HksOpensslRsaCrypt(key, usageSpec, message, true, cipherText); +#endif default: HKS_LOG_E("Unsupport alg now!"); return HKS_ERROR_INVALID_ARGUMENT; @@ -460,8 +554,14 @@ int32_t HksCryptoHalDecrypt(const struct HksBlob *key, const struct HksUsageSpec } switch (usageSpec->algType) { +#ifdef HKS_SUPPORT_AES_C case HKS_ALG_AES: return HksOpensslAesDecrypt(key, usageSpec, message, cipherText); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT) + case HKS_ALG_RSA: + return HksOpensslRsaCrypt(key, usageSpec, message, false, cipherText); +#endif default: HKS_LOG_E("Unsupport alg now!"); return HKS_ERROR_INVALID_ARGUMENT; diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c index 72a1902d7c66e6a8f5c45f7f1a12d47b0b21b43a..55f695466ca0dbde00abbd8b124f214342f7c6a3 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c @@ -24,6 +24,8 @@ static int32_t CheckDigestAlg(uint32_t alg) { switch (alg) { + case HKS_DIGEST_SHA1: + case HKS_DIGEST_SHA224: case HKS_DIGEST_SHA256: case HKS_DIGEST_SHA384: case HKS_DIGEST_SHA512: diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c index 1647fad27ce229e96ce91378507d652fa7a57b8f..deaf1763b27dfca4165b2dbf43b399908d48c0fe 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c @@ -13,12 +13,23 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_HMAC_C + #include "hks_openssl_hmac.h" #include #include +#include +#include "hks_common_check.h" #include "hks_log.h" +#include "hks_mem.h" #include "hks_openssl_engine.h" #include "hks_type_inner.h" @@ -42,6 +53,10 @@ static int32_t HmacCheckBuffer(const struct HksBlob *key, const struct HksBlob * static uint32_t HmacGetDigestLen(uint32_t alg) { switch (alg) { + case HKS_DIGEST_SHA1: + return HKS_DIGEST_SHA1_LEN; + case HKS_DIGEST_SHA224: + return HKS_DIGEST_SHA224_LEN; case HKS_DIGEST_SHA256: return HKS_DIGEST_SHA256_LEN; case HKS_DIGEST_SHA384: @@ -51,14 +66,60 @@ static uint32_t HmacGetDigestLen(uint32_t alg) } } -static int32_t HmacCheckParam(const struct HksBlob *key, uint32_t alg, - const struct HksBlob *msg, const struct HksBlob *mac) +static int32_t HmacGenKeyCheckParam(const struct HksKeySpec *spec) +{ + if (spec->keyLen % BIT_NUM_OF_UINT8 != 0) { + return HKS_ERROR_INVALID_ARGUMENT; + } + return HKS_SUCCESS; +} + +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY +int32_t HksOpensslHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + if (HmacGenKeyCheckParam(spec) != HKS_SUCCESS) { + HKS_LOG_E("aes generate key invalid params!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + + uint32_t keySizeByte = spec->keyLen / BIT_NUM_OF_UINT8; + int32_t ret = HKS_FAILURE; + + uint8_t *tmpKey = (uint8_t *)HksMalloc(keySizeByte); + if (tmpKey == NULL) { + HKS_LOG_E("malloc buffer failed"); + return HKS_ERROR_MALLOC_FAIL; + } + + do { + if (RAND_bytes(tmpKey, keySizeByte) <= 0) { + HKS_LOG_E("generate key is failed:0x%x", ret); + break; + } + + key->data = tmpKey; + key->size = keySizeByte; + ret = HKS_SUCCESS; + } while (0); + + if (ret != HKS_SUCCESS) { + (void)memset_s(tmpKey, keySizeByte, 0, keySizeByte); + HksFree(tmpKey); + } + return ret; +} +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ + +static int32_t HmacCheckParam( + const struct HksBlob *key, uint32_t alg, const struct HksBlob *msg, const struct HksBlob *mac) { if (HmacCheckBuffer(key, msg, mac) != HKS_SUCCESS) { HKS_LOG_E("Invalid Buffer Info"); return HKS_ERROR_INVALID_ARGUMENT; } - if ((alg != HKS_DIGEST_SHA256) && (alg != HKS_DIGEST_SHA384) && (alg != HKS_DIGEST_SHA512)) { + + if ((alg != HKS_DIGEST_SHA1) && (alg != HKS_DIGEST_SHA224) && (alg != HKS_DIGEST_SHA256) && + (alg != HKS_DIGEST_SHA384) && (alg != HKS_DIGEST_SHA512)) { HKS_LOG_E("Invalid alg(0x%x)", alg); return HKS_ERROR_INVALID_ARGUMENT; } @@ -71,8 +132,9 @@ static int32_t HmacCheckParam(const struct HksBlob *key, uint32_t alg, return HKS_SUCCESS; } -int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, - struct HksBlob *mac) +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) +int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { if (HmacCheckParam(key, digestAlg, msg, mac) != HKS_SUCCESS) { return HKS_ERROR_INVALID_ARGUMENT; @@ -91,3 +153,5 @@ int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const stru } return HKS_SUCCESS; } +#endif /* HKS_SUPPORT_HMAC_SHA1 */ +#endif /* HKS_SUPPORT_HMAC_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c new file mode 100755 index 0000000000000000000000000000000000000000..f21f05adcaf93a3927b67208ae7981273457af8f --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c @@ -0,0 +1,464 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_RSA_C + +#include "hks_openssl_rsa.h" + +#include +#include + +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_openssl_engine.h" +#include "hks_type_inner.h" + +static int32_t RsaGenKeyCheckParam(const struct HksKeySpec *spec) +{ + switch (spec->keyLen) { + case HKS_RSA_KEY_SIZE_512: + case HKS_RSA_KEY_SIZE_768: + case HKS_RSA_KEY_SIZE_1024: + case HKS_RSA_KEY_SIZE_2048: + case HKS_RSA_KEY_SIZE_3072: + case HKS_RSA_KEY_SIZE_4096: + return HKS_SUCCESS; + default: + HKS_LOG_E("Invlid rsa key len %x!", spec->keyLen); + return HKS_ERROR_INVALID_ARGUMENT; + } +} + +static int32_t RsaCheckKeyMaterial(const struct HksBlob *key) +{ + const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); + if (keyMaterial->keyAlg != HKS_ALG_RSA) { + return HKS_ERROR_INVALID_KEY_INFO; + } + if (key->size != sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize) { + return HKS_ERROR_INVALID_KEY_INFO; + } + return HKS_SUCCESS; +} + +static RSA *InitRsaStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); + uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + + uint32_t offset = sizeof(*keyMaterial); + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize); + BIGNUM *n = BN_bin2bn(buff, keyMaterial->nSize, NULL); + offset += keyMaterial->nSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize); + BIGNUM *e = BN_bin2bn(buff, keyMaterial->eSize, NULL); + offset += keyMaterial->eSize; + BIGNUM *d = NULL; + if (needPrivateExponent) { + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize); + d = BN_bin2bn(buff, keyMaterial->dSize, NULL); + } + + RSA *rsa = RSA_new(); + int32_t ret = RSA_set0_key(rsa, n, e, d); + if (ret != HKS_OPENSSL_SUCCESS) { + RSA_free(rsa); + return NULL; + } + + return rsa; +} + +#ifdef HKS_SUPPORT_RSA_GENERATE_KEY +static int32_t RsaSaveKeyMaterial(const RSA *rsa, const uint32_t keySize, struct HksBlob *key) +{ + const uint32_t keyByteLen = keySize / HKS_BITS_PER_BYTE; + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialRsa) + keyByteLen * HKS_RSA_KEYPAIR_CNT; + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_RSA; + keyMaterial->keySize = keySize; + + uint8_t tmp_buff[keyByteLen]; + memset_s(tmp_buff, keyByteLen, 0x00, keyByteLen); + + uint32_t offset = sizeof(*keyMaterial); + keyMaterial->nSize = BN_bn2bin(RSA_get0_n(rsa), tmp_buff); + memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->nSize); + + offset += keyMaterial->nSize; + keyMaterial->eSize = BN_bn2bin(RSA_get0_e(rsa), tmp_buff); + memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->eSize); + + offset += keyMaterial->eSize; + keyMaterial->dSize = BN_bn2bin(RSA_get0_d(rsa), tmp_buff); + memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->dSize); + + key->data = rawMaterial; + key->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize; + + return HKS_SUCCESS; +} + +int32_t HksOpensslRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + if (RsaGenKeyCheckParam(spec) != HKS_SUCCESS) { + HKS_LOG_E("rsa generate key invalid params!"); + return HKS_ERROR_INVALID_ARGUMENT; + } + + RSA *rsa = RSA_new(); + BIGNUM *e = BN_new(); + + BN_set_word(e, RSA_F4); + + if (RSA_generate_key_ex(rsa, spec->keyLen, e, NULL) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + BN_free(e); + RSA_free(rsa); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + BN_free(e); + + int32_t ret = RsaSaveKeyMaterial(rsa, spec->keyLen, key); + + RSA_free(rsa); + + return ret; +} +#endif /* HKS_SUPPORT_RSA_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_RSA_GET_PUBLIC_KEY +int32_t HksOpensslGetRsaPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)input->data; + output->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; + + struct KeyMaterialRsa *publickeyMaterial = (struct KeyMaterialRsa *)output->data; + publickeyMaterial->keyAlg = keyMaterial->keyAlg; + publickeyMaterial->keySize = keyMaterial->keySize; + publickeyMaterial->nSize = keyMaterial->nSize; + publickeyMaterial->eSize = keyMaterial->eSize; + publickeyMaterial->dSize = 0; + + memcpy_s(output->data + sizeof(struct KeyMaterialRsa), + output->size - sizeof(struct KeyMaterialRsa), + input->data + sizeof(struct KeyMaterialRsa), + keyMaterial->nSize + keyMaterial->eSize); + + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_RSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_RSA_CRYPT +static int32_t GetRsaCryptPadding(uint32_t padding, uint32_t *rsaPadding) +{ + switch (padding) { + case HKS_PADDING_NONE: + *rsaPadding = RSA_NO_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_PKCS1_V1_5: + *rsaPadding = RSA_PKCS1_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_OAEP: + *rsaPadding = RSA_PKCS1_OAEP_PADDING; + return HKS_SUCCESS; + default: + return HKS_FAILURE; + } +} + +static EVP_PKEY_CTX *InitEvpPkeyCtx(const struct HksBlob *key, bool encrypt) +{ + int32_t ret = RsaCheckKeyMaterial(key); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key material failed"); + return NULL; + } + + RSA *rsa = InitRsaStruct(key, !encrypt); + if (rsa == NULL) { + HKS_LOG_E("initialize rsa key failed"); + return NULL; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + RSA_free(rsa); + HksLogOpensslError(); + return NULL; + } + + ret = EVP_PKEY_assign_RSA(pkey, rsa); + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + RSA_free(rsa); + EVP_PKEY_free(pkey); + return NULL; + } + + EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(pkey, NULL); + if (ctx == NULL) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + return NULL; + } + + if (encrypt) { + ret = EVP_PKEY_encrypt_init(ctx); + } else { + ret = EVP_PKEY_decrypt_init(ctx); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + return NULL; + } + + EVP_PKEY_free(pkey); + return ctx; +} + +static int32_t HksOpensslRsaCryptInit(EVP_PKEY_CTX *ctx, const struct HksUsageSpec *usageSpec) +{ + int32_t ret; + uint32_t padding = 0; + if (GetRsaCryptPadding(usageSpec->padding, &padding) != HKS_SUCCESS) { + HKS_LOG_E("Unsupport padding."); + return HKS_FAILURE; + } + + ret = EVP_PKEY_CTX_set_rsa_padding(ctx, padding); + if (ret <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + + if (usageSpec->padding == HKS_PADDING_OAEP) { + const EVP_MD *md = GetOpensslAlg(usageSpec->digest); + if (md == NULL || EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) <= 0 || EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) <= 0) { + HksLogOpensslError(); + return HKS_FAILURE; + } + } + return HKS_SUCCESS; +} + +int32_t HksOpensslRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) +{ + int32_t ret; + EVP_PKEY_CTX *ctx = InitEvpPkeyCtx(key, encrypt); + if (ctx == NULL) { + HksLogOpensslError(); + return HKS_FAILURE; + } + + if (HksOpensslRsaCryptInit(ctx, usageSpec) != HKS_SUCCESS) { + EVP_PKEY_CTX_free(ctx); + return HKS_FAILURE; + } + + size_t outLen; + if (encrypt) { + ret = EVP_PKEY_encrypt(ctx, NULL, &outLen, message->data, message->size); + } else { + ret = EVP_PKEY_decrypt(ctx, NULL, &outLen, message->data, message->size); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_PKEY_CTX_free(ctx); + return HKS_FAILURE; + } + + if (outLen > cipherText->size) { + HksLogOpensslError(); + EVP_PKEY_CTX_free(ctx); + return HKS_FAILURE; + } + + if (encrypt) { + ret = EVP_PKEY_encrypt(ctx, cipherText->data, &outLen, message->data, message->size); + } else { + ret = EVP_PKEY_decrypt(ctx, cipherText->data, &outLen, message->data, message->size); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_PKEY_CTX_free(ctx); + return HKS_FAILURE; + } + cipherText->size = outLen; + + EVP_PKEY_CTX_free(ctx); + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_RSA_CRYPT */ + +#ifdef HKS_SUPPORT_RSA_SIGN_VERIFY +static int32_t GetRsaSignPadding(uint32_t padding, uint32_t *rsaPadding) +{ + switch (padding) { + case HKS_PADDING_PKCS1_V1_5: + *rsaPadding = RSA_PKCS1_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_PSS: + *rsaPadding = RSA_PKCS1_PSS_PADDING; + return HKS_SUCCESS; + default: + return HKS_FAILURE; + } +} + +static EVP_MD_CTX *InitRsaMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) +{ + int32_t ret = HKS_FAILURE; + uint32_t opensslPadding = 0; + + if (GetRsaSignPadding(usageSpec->padding, &opensslPadding) != HKS_SUCCESS) { + HKS_LOG_E("Unsupport padding."); + return NULL; + } + + RSA *rsa = NULL; + EVP_PKEY *pkey = NULL; + EVP_MD_CTX *ctx = NULL; + + do { + rsa = InitRsaStruct(key, signing); + if (rsa == NULL) { + HKS_LOG_E("initialize rsa key failed"); + break; + } + + pkey = EVP_PKEY_new(); + if (pkey == NULL) { + break; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != HKS_OPENSSL_SUCCESS) { + break; + } + rsa = NULL; + + ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + break; + } + + if (signing) { + ret = EVP_DigestSignInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } else { + ret = EVP_DigestVerifyInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } + if (ret != HKS_OPENSSL_SUCCESS) { + break; + } + + if (usageSpec->padding == HKS_PADDING_PSS) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(ctx), opensslPadding) != HKS_OPENSSL_SUCCESS) { + break; + } + } + ret = HKS_SUCCESS; + } while (0); + + SELF_FREE_PTR(rsa, RSA_free); + SELF_FREE_PTR(pkey, EVP_PKEY_free); + if (ret != HKS_SUCCESS) { + HksLogOpensslError(); + SELF_FREE_PTR(ctx, EVP_MD_CTX_free); + } + + return ctx; +} + +int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, true); + if (ctx == NULL) { + HKS_LOG_E("initialize rsa md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + size_t outLen = 0; + if (EVP_DigestSignFinal(ctx, NULL, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (outLen > signature->size) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + signature->size = outLen; + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} + +int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, false); + if (ctx == NULL) { + HKS_LOG_E("initialize rsa md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ + +#endif /* HKS_SUPPORT_RSA_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/test/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..c05ef21321e51a8ec9da02edfe1085b3aa11b401 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/BUILD.gn @@ -0,0 +1,20 @@ +# Copyright (c) 2021 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. + +import("//build/ohos.gni") +import("//build/test.gni") + +group("crypto_engine_test") { + testonly = true + deps = [ "unittest:crypto_engine_unit_test" ] +} diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..f5cf6b7a66e301123b7416121ec8ca152717a108 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn @@ -0,0 +1,88 @@ +# Copyright (c) 2021 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. + +import("//base/security/huks/huks.gni") +import("//build/ohos.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/hal_unittest" + +config("json_config") { + cflags_cc = [ "-fexceptions" ] +} + +ohos_unittest("crypto_engine_unit_test") { + module_out_path = module_output_path + include_dirs = [ + ".", + "include", + "//base/security/huks/frameworks/huks_standard/main/common/include", + ] + + sources = [ + "hks_crypto_hal_aes_cipher.cpp", + "hks_crypto_hal_aes_decrypt.cpp", + "hks_crypto_hal_aes_encrypt.cpp", + "hks_crypto_hal_aes_key.cpp", + "hks_crypto_hal_common.cpp", + "hks_crypto_hal_common.h", + "hks_crypto_hal_dh.cpp", + "hks_crypto_hal_dh_agree.cpp", + "hks_crypto_hal_dsa_key.cpp", + "hks_crypto_hal_dsa_sign.cpp", + "hks_crypto_hal_ecc_key.cpp", + "hks_crypto_hal_ecdh_agree.cpp", + "hks_crypto_hal_ecdsa_sign.cpp", + "hks_crypto_hal_hmac_hmac.cpp", + "hks_crypto_hal_hmac_key.cpp", + "hks_crypto_hal_rsa_cipher.cpp", + "hks_crypto_hal_rsa_decrypt.cpp", + "hks_crypto_hal_rsa_encrypt.cpp", + "hks_crypto_hal_rsa_key.cpp", + "hks_crypto_hal_rsa_oaep_decrypt.cpp", + "hks_crypto_hal_rsa_oaep_encrypt.cpp", + "hks_crypto_hal_rsa_pkcs1_sign.cpp", + "hks_crypto_hal_rsa_pss_sign.cpp", + ] + if (use_crypto_lib == "openssl") { + sources += [ "hks_crypto_hal_api_openssl.cpp" ] + } + if (use_crypto_lib == "mbedtls") { + sources += [ "hks_crypto_hal_api_mbedtls.cpp" ] + } + + if (use_crypto_lib == "openssl") { + defines = [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines = [ "_USE_MBEDTLS_" ] + } + + configs = [ "//utils/native/base:utils_config" ] + + deps = [ + "//base/security/huks/frameworks/huks_standard/main/os_dependency:libhuks_os_dependency_standard_static", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] + + if (use_crypto_lib == "openssl") { + deps += [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/openssl:libhuks_openssl_standard_static" ] + } + if (use_crypto_lib == "mbedtls") { + deps += [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/mbedtls:libhuks_mbedtls_standard_static" ] + } + + subsystem_name = "security" + part_name = "huks_standard" +} diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp new file mode 100755 index 0000000000000000000000000000000000000000..539caf0aac51d8a39cc942f1fb4cbb6e0e42a6af --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp @@ -0,0 +1,677 @@ +/* + * Copyright (c) 2021 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 "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[16] = {0}; +const HksCipherParam tagIv = { .iv = { .size = 16, .data = (uint8_t *)IV } }; +const HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = (uint8_t *)IV }, + .aad = { .size = 0, .data = nullptr }, + .tagLenEnc = 16, + .payloadLen = 0, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_012_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalAesCipher : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + HksBlob plaintext = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + if (testCaseParams.usageSpec.mode == HKS_MODE_GCM) { + struct HksAeadParam aeadParamForGcm; + aeadParamForGcm.nonce = { .size = 16, .data = (uint8_t *)IV }; + aeadParamForGcm.aad = { .size = 0, .data = nullptr }; + aeadParamForGcm.tagDec = tagAead; + aeadParamForGcm.payloadLen = 0; + HksUsageSpec usageSpecForGCM = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParamForGcm, + }; + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &usageSpecForGCM, &cipherText, &plaintext), testCaseParams.decryptResult); + } else { + EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &plaintext), + testCaseParams.decryptResult); + } + EXPECT_EQ(message.size, plaintext.size); + EXPECT_EQ(HksMemCmp(message.data, plaintext.data, plaintext.size), HKS_SUCCESS); + } + + HksFree(key.data); + HksFree(cipherText.data); + HksFree(plaintext.data); + HksFree(tagAead.data); + } +}; + +/** + * @tc.number : HksCryptoHalAesCipher_001 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-NOPADDING key + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_002 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_003 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_004 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_005 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_006 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_007 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_008 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_009 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_010 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_011 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_012 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_013 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_014 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_015 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_016 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_017 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_018 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..11d8f0ccd6d6631e47732af3c4d95372e25a06ff --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp @@ -0,0 +1,560 @@ +/* + * Copyright (c) 2021 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 "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode decryptResult; +}; +struct TestCaseParamsForGcm { + std::string keyData; + std::string hexData; + std::string tagDec; + + HksErrorCode decryptResult; +}; + +uint8_t IV[16] = {0}; +HksCipherParam tagIv = { .iv = { .size = 16, .data = IV } }; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b657930", + .hexData = "a043f74ce2620fc939811e9a949e9f0576c60fb964670ed6e626260f7e6d972aca0d0aeff876a8f03fd8ed8b91ff3f9a", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb0935670f5531be24753f04e3200829ea2fd60", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS = { + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "fd692103d931c663a0371bd250dd883aed48379774bfba64327cc4a3ea19afae", + .tagDec = "43a345ff5f3af4bb383f999393949acc", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "7897f888bda5244c049da27f1533dc80accf7a0c8a9169fa64779d1f34be146dcb0f793048dee9efaa032c7901b07b64", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf343111", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf343111cf0afb8fc67acf62db781f324ecc361c", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS = { + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "06c34934467ad390f5f54410ac20c875feda920d514c3e43819ce16e1e2e3335", + .tagDec = "b3ad99cd7951405f1eeefb4e54783f17", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "acec21f1488248cdcf6f24a15124b1a68e401efd146cd944fabd84081b76dacf89989a52f8fc1e31dacb820ec8102365", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "776a9f622d0978f89fff5c61ae5d4693776a9f622d0978f89fff5c61ae5d469379ea9dc7d7419ec0ea457aa041e1007a", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS = { + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "da047651955c64daa5cac9b0082f1567235e682041061fef12f896ba83bb1fde", + .tagDec = "35a956a070d5ed7472a9b66165bcada7", + + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalAesDecrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) { + outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + } + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText), testCaseParams.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } + + void GcmRunTestCase(const TestCaseParamsForGcm &testCaseParamsForGcm) + { + uint32_t keyLen = testCaseParamsForGcm.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.keyData[2 * ii]); + } + uint32_t inLen = testCaseParamsForGcm.hexData.length() / 2; + uint32_t outLen = inLen; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + uint32_t tagDecSize = testCaseParamsForGcm.tagDec.length() / 2; + HksBlob tagDecBlob = { .size = tagDecSize, .data = (uint8_t *)HksMalloc(tagDecSize) }; + for (uint32_t ii = 0; ii < tagDecSize; ii++) { + tagDecBlob.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.tagDec[2 * ii]); + } + HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = IV }, + .aad = { .size = 0, .data = nullptr }, + .tagDec = tagDecBlob, + .payloadLen = 0, + }; + HksUsageSpec usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }; + EXPECT_EQ(HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText), testCaseParamsForGcm.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + HksFree(tagDecBlob.data); + } +}; + +/** + * @tc.number : HksCryptoHalAesDecrypt_001 + * @tc.name : HksCryptoHalAesDecrypt_001 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_002 + * @tc.name : HksCryptoHalAesDecrypt_002 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_003 + * @tc.name : HksCryptoHalAesDecrypt_003 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_004 + * @tc.name : HksCryptoHalAesDecrypt_004 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_005 + * @tc.name : HksCryptoHalAesDecrypt_005 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_006 + * @tc.name : HksCryptoHalAesDecrypt_006 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTest | Level0) +{ + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_007 + * @tc.name : HksCryptoHalAesDecrypt_007 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_008 + * @tc.name : HksCryptoHalAesDecrypt_008 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_009 + * @tc.name : HksCryptoHalAesDecrypt_009 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_010 + * @tc.name : HksCryptoHalAesDecrypt_010 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_011 + * @tc.name : HksCryptoHalAesDecrypt_011 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_012 + * @tc.name : HksCryptoHalAesDecrypt_012 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTest | Level0) +{ + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_013 + * @tc.name : HksCryptoHalAesDecrypt_013 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_014 + * @tc.name : HksCryptoHalAesDecrypt_014 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_015 + * @tc.name : HksCryptoHalAesDecrypt_015 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_016 + * @tc.name : HksCryptoHalAesDecrypt_016 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_017 + * @tc.name : HksCryptoHalAesDecrypt_017 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesDecrypt_018 + * @tc.name : HksCryptoHalAesDecrypt_018 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTest | Level0) +{ + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a3519d2ca243f5cf595f7f17710309f3d82f9568 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp @@ -0,0 +1,541 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode encryptResult; +}; + +uint8_t IV[16] = {0}; +HksCipherParam tagIv = { .iv = { .size = 16, .data = IV } }; +HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = IV }, + .aad = { .size = 0, .data = nullptr }, + .tagLenEnc = 16, + .payloadLen = 0, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff", +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff", +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalAesEncrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) { + outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + } + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + HksFree(tagAead.data); + } +}; + +/** + * @tc.number : HksCryptoHalAesEncrypt_001 + * @tc.name : HksCryptoHalAesEncrypt_001 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_002 + * @tc.name : HksCryptoHalAesEncrypt_002 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_003 + * @tc.name : HksCryptoHalAesEncrypt_003 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_004 + * @tc.name : HksCryptoHalAesEncrypt_004 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_005 + * @tc.name : HksCryptoHalAesEncrypt_005 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_006 + * @tc.name : HksCryptoHalAesEncrypt_006 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_007 + * @tc.name : HksCryptoHalAesEncrypt_007 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_008 + * @tc.name : HksCryptoHalAesEncrypt_008 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_009 + * @tc.name : HksCryptoHalAesEncrypt_009 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_010 + * @tc.name : HksCryptoHalAesEncrypt_010 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_011 + * @tc.name : HksCryptoHalAesEncrypt_011 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_012 + * @tc.name : HksCryptoHalAesEncrypt_012 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_013 + * @tc.name : HksCryptoHalAesEncrypt_013 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_014 + * @tc.name : HksCryptoHalAesEncrypt_014 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_015 + * @tc.name : HksCryptoHalAesEncrypt_015 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_016 + * @tc.name : HksCryptoHalAesEncrypt_016 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_017 + * @tc.name : HksCryptoHalAesEncrypt_017 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesEncrypt_018 + * @tc.name : HksCryptoHalAesEncrypt_018 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..e688ed030ae5956a7f32040da307d490287953f9 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_001_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +} // namespace + +class HksCryptoHalAesKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalAesKey_001 + * @tc.name : HksCryptoHalAesKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-128bit key. + */ +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesKey_002 + * @tc.name : HksCryptoHalAesKey_002 + * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-192bit key. + */ +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesKey_003 + * @tc.name : HksCryptoHalAesKey_003 + * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-256bit key. + */ +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_003_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp new file mode 100755 index 0000000000000000000000000000000000000000..461086ad2ff0af07f371770886bf9e72fa68acc1 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp @@ -0,0 +1,486 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalApiMbedtls_001 + * @tc.name : HksCryptoHalApiMbedtls_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + .algParam = nullptr, + }; + + ret = HksCryptoHalGenerateKey(&spec, NULL); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_002 + * @tc.name : HksCryptoHalApiMbedtls_002 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = 0xffff, + .keyLen = 0, + .algParam = nullptr, + }; + + HksBlob key = {}; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_003 + * @tc.name : HksCryptoHalApiMbedtls_003 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is AES keyLen is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_AES, + .keyLen = 0, + .algParam = nullptr, + }; + + HksBlob key = {}; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_004 + * @tc.name : HksCryptoHalApiMbedtls_004 + * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level0) +{ + int32_t ret; + + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + HksBlob tagAead = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + message = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + cipherText = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_005 + * @tc.name : HksCryptoHalApiMbedtls_005 + * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level0) +{ + int32_t ret; + + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + message = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + cipherText = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_006 + * @tc.name : HksCryptoHalApiMbedtls_006 + * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + HksBlob tagAead = { .size = 1, .data = buff }; + + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); + + key.size = sizeof(buff); + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_007 + * @tc.name : HksCryptoHalApiMbedtls_007 + * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); + + key.size = sizeof(buff); + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_008 + * @tc.name : HksCryptoHalApiMbedtls_008 + * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt padding is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_PADDING, ret); + + spec.mode = HKS_MODE_ECB; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_PADDING, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_009 + * @tc.name : HksCryptoHalApiMbedtls_009 + * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt CBC mode nopadding with large iv. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + uint8_t iv[20] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + + spec.algParam = &cipherParam; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_IV, ret); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_010 + * @tc.name : HksCryptoHalApiMbedtls_010 + * @tc.desc : Using HksCryptoHalDecrypt -- RSA decrypt key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + uint8_t iv[20] = {0}; + HksBlob key; + HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } }; + HksUsageSpec spec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + spec.algParam = &cipherParam; + + uint32_t keyLen = sizeof(KeyMaterialRsa) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + + (HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096)); + key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; + keyMaterial->keyAlg = HKS_ALG_RSA; + keyMaterial->keySize = HKS_RSA_KEY_SIZE_4096; + keyMaterial->nSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); + keyMaterial->eSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); + keyMaterial->dSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key.size -= HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); + keyMaterial->dSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); + keyMaterial->keySize = 2000; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); + + key.size = sizeof(KeyMaterialRsa); + keyMaterial->keySize = HKS_RSA_KEY_SIZE_4096; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_KEY_INFO, ret); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_011 + * @tc.name : HksCryptoHalApiMbedtls_011 + * @tc.desc : Using HksMbedtlsGetRsaPubKey -- RSA in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; + HksBlob keyOut = { .size = sizeof(KeyMaterialRsa), .data = (uint8_t *)HksMalloc(keyOutLen) }; + + keyMaterial->keySize = 2000; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); + + keyMaterial->keySize = HKS_RSA_KEY_SIZE_2048; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_012 + * @tc.name : HksCryptoHalApiMbedtls_012 + * @tc.desc : Using HksMbedtlsEccGenerateKey -- key size is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + HksBlob key = { .size = 0, .data = NULL }; + + spec.keyLen += 1; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_013 + * @tc.name : HksCryptoHalApiMbedtls_013 + * @tc.desc : Using HksMbedtlsGetEccPubKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + HksBlob keyOut = { .size = sizeof(KeyMaterialEcc), .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + + key.size -= 1; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_INFO); + key.size += 1; + + keyMaterial->zSize = 0xFFFF; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + + keyMaterial->keySize += 1; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); + + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksCryptoHalApiMbedtls_014 + * @tc.name : HksCryptoHalApiMbedtls_014 + * @tc.desc : Using HksMbedtlsDhGenerateKey -- key size is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + spec.keyLen += 1; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_015 + * @tc.name : HksCryptoHalApiMbedtls_015 + * @tc.desc : Using HksMbedtlsGetDhPubKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialDh) + keyMaterial->pubKeySize; + HksBlob keyOut = { .size = sizeof(KeyMaterialDh), .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + + key.size = keyOut.size; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_016 + * @tc.name : HksCryptoHalApiMbedtls_016 + * @tc.desc : Using HksMbedtlsDhAgreeKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data; + + uint32_t keyOutLen = HKS_KEY_BYTES(spec.keyLen); + HksBlob sharedKey = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; + + keyMaterial->keySize -= 1; + ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); + + sharedKey.size -= 1; + ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(sharedKey); + HKS_FREE_BLOB(key); +} +#endif +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp new file mode 100755 index 0000000000000000000000000000000000000000..4a10d1c3002359c5a38937636c9702419e2da871 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp @@ -0,0 +1,568 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalApiOpenssl_001 + * @tc.name : HksCryptoHalApiOpenssl_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_128, + }; + + ret = HksCryptoHalGenerateKey(&spec, NULL); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_002 + * @tc.name : HksCryptoHalApiOpenssl_002 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = 0xffff, + .keyLen = 0, + }; + + HksBlob key = {}; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_003 + * @tc.name : HksCryptoHalApiOpenssl_003 + * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- keyLen is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_AES, + .keyLen = 1, + }; + + HksBlob key = {}; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_RSA; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_ECC; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_DSA; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_HMAC; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + +#ifdef HKS_SUPPORT_DH_C + spec.algType = HKS_ALG_DH; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); +#endif +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_004 + * @tc.name : HksCryptoHalApiOpenssl_004 + * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level0) +{ + int32_t ret; + + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + HksBlob tagAead = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + message = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + cipherText = { .size = 1, .data = buff }; + ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_005 + * @tc.name : HksCryptoHalApiOpenssl_005 + * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level0) +{ + int32_t ret; + + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + message = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + cipherText = { .size = 1, .data = buff }; + ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_006 + * @tc.name : HksCryptoHalApiOpenssl_006 + * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + HksBlob tagAead = { .size = 1, .data = buff }; + + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.mode = HKS_MODE_CBC; + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.mode = HKS_MODE_CTR; + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.mode = HKS_MODE_ECB; + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.mode = HKS_MODE_GCM; + ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); + EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_007 + * @tc.name : HksCryptoHalApiOpenssl_007 + * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + key.size = sizeof(buff); + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.mode = HKS_MODE_GCM; + key.size = 1; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_008 + * @tc.name : HksCryptoHalApiOpenssl_008 + * @tc.desc : Using HksCryptoHalDecrypt -- decrypt padding is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level0) +{ + int32_t ret; + + uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret); + + spec.mode = HKS_MODE_ECB; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret); + + spec.algType = HKS_ALG_RSA; + ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); + EXPECT_EQ(HKS_FAILURE, ret); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_009 + * @tc.name : HksCryptoHalApiOpenssl_009 + * @tc.desc : Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level0) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalSign(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_010 + * @tc.name : HksCryptoHalApiOpenssl_010 + * @tc.desc : Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level0) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalVerify(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_011 + * @tc.name : HksCryptoHalApiOpenssl_011 + * @tc.desc : RSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level0) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_RSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + signSpec.padding = HKS_PADDING_PSS; + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_012 + * @tc.name : HksCryptoHalApiOpenssl_012 + * @tc.desc : RSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level0) +{ + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_RSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + signSpec.padding = HKS_PADDING_PSS; + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_013 + * @tc.name : HksCryptoHalApiOpenssl_013 + * @tc.desc : DSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level0) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + }; + + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_DSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_014 + * @tc.name : HksCryptoHalApiOpenssl_014 + * @tc.desc : DSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level0) +{ + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_DSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_015 + * @tc.name : HksCryptoHalApiOpenssl_015 + * @tc.desc : ECDSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level0) +{ + uint8_t buff[HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_ECC }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_016 + * @tc.name : HksCryptoHalApiOpenssl_016 + * @tc.desc : ECDSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level0) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_ECC }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_017 + * @tc.name : HksCryptoHalApiOpenssl_017 + * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level0) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksBlob pubKey = { .size = 0, .data = nullptr }; + HksKeySpec spec = { .algType = 0xffff }; + HksBlob agreeKey = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + pubKey = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + agreeKey = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_018 + * @tc.name : HksCryptoHalApiOpenssl_018 + * @tc.desc : ECDH Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level0) +{ + HksKeySpec keySpec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksBlob pubKey = { .size = sizeof(buff), .data = buff }; + HksKeySpec spec = { .algType = HKS_ALG_ECDH }; + HksBlob agreeKey = { .size = sizeof(buff), .data = buff }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + spec.keyLen = HKS_ECC_KEY_SIZE_256; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_FAILURE); + + HksCryptoHalGenerateKey(&keySpec, &key); + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_FAILURE); + HKS_FREE_BLOB(key); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksCryptoHalApiOpenssl_019 + * @tc.name : HksCryptoHalApiOpenssl_019 + * @tc.desc : DH Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level0) +{ + HksKeySpec keySpec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_DH_KEY_SIZE_2048)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksBlob pubKey = { .size = sizeof(buff), .data = buff }; + HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 }; + HksBlob agreeKey = { .size = sizeof(buff), .data = buff }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_KEY_SIZE); + + spec.keyLen = 0; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HksCryptoHalGenerateKey(&keySpec, &key); + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HKS_FREE_BLOB(key); +} +#endif + +/** + * @tc.number : HksCryptoHalApiOpenssl_020 + * @tc.name : HksCryptoHalApiOpenssl_020 + * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level0) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.cpp new file mode 100755 index 0000000000000000000000000000000000000000..cde5e65321e63391559a6fd622f1cd97930963d9 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.cpp @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 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 "hks_crypto_hal_common.h" + +uint8_t HksCryptoHalCommon::HexChar(char hex) const +{ + if (hex >= '0' && hex <= '9') { + return hex - '0'; + } else if (hex >= 'A' && hex <= 'F') { + return hex - 'A' + 0X0A; + } else if (hex >= 'a' && hex <= 'f') { + return hex - 'a' + 0X0A; + } else { + return 0; + } +} + +uint8_t HksCryptoHalCommon::ReadHex(const uint8_t hex[2]) const +{ + return HexChar(*hex) * 16 + HexChar(*(hex + 1)); +} \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.h b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.h new file mode 100755 index 0000000000000000000000000000000000000000..c77b5021f0b3b104d5ba864a6df52fabdf35b150 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_common.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_CRYPTO_HAL_COMMON_H +#define HKS_CRYPTO_HAL_COMMON_H + +#include "hks_type_inner.h" + +class HksCryptoHalCommon { +public: + HksCryptoHalCommon() + {} + virtual ~HksCryptoHalCommon() + {} + +protected: + uint8_t HexChar(char hex) const; + uint8_t ReadHex(const uint8_t hex[2]) const; + + const uint32_t HKS_PADDING_SUPPLENMENT = 16; +}; +#endif // HKS_CRYPTO_HAL_COMMON_H \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp new file mode 100755 index 0000000000000000000000000000000000000000..09fe2439aa9e62f07918eaf5e75721d30a80cf49 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2021 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 "hks_mem.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_config.h" + +#ifdef HKS_SUPPORT_DH_C + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_001_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048, }, + .generateKeyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_002_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072, }, + .generateKeyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_003_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096, }, + .generateKeyResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { 0, NULL }; + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + HKS_FREE_BLOB(key); + } +}; + +/** + * @tc.number : HksCryptoHalDh_001 + * @tc.name : HksCryptoHalDh_001 + * @tc.desc : Generate Dh-2048 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalDh_002 + * @tc.name : HksCryptoHalDh_002 + * @tc.desc : Generate Dh-3072 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalDh_003 + * @tc.name : HksCryptoHalDh_003 + * @tc.desc : Generate Dh-4096 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_003_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp new file mode 100755 index 0000000000000000000000000000000000000000..b33d364ec817edff37a8f56f185fe48bfccdf506 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +#ifdef HKS_SUPPORT_DH_C + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS = { + .spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS = { + .spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_3072, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS = { + .spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_4096, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +}; + +/** + * @tc.number : HksCryptoHalDhAgree_001 + * @tc.name : HksCryptoHalDhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-2048 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalDhAgree_002 + * @tc.name : HksCryptoHalDhAgree_002 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-3072 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalDhAgree_003 + * @tc.name : HksCryptoHalDhAgree_003 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-4096 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d6d204a439dd1d1fc21fc605f5ec0a02f2b82738 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +class HksCryptoHalDsaKey : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalDsaKey_001 + * @tc.name : HksCryptoHalDsaKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate DSA-256bit key. + */ +HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + ret = HksCryptoHalGenerateKey(&spec, &key); +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) +#if defined(_USE_OPENSSL_) + ASSERT_EQ(HKS_SUCCESS, ret); + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); +#endif +#if defined(_USE_MBEDTLS_) + ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); + HksFree(key.data); +#endif +#else + ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); +#endif +} + +/** + * @tc.number : HksCryptoHalDsaKey_002 + * @tc.name : HksCryptoHalDsaKey_002 + * @tc.desc : Generate key and export public key with DSA. + */ +HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 512, + }; + + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); +#ifdef _USE_OPENSSL_ + ASSERT_EQ(ret, HKS_SUCCESS); +#endif +#ifdef _USE_MBEDTLS_ + ASSERT_EQ(ret, HKS_ERROR_NOT_SUPPORTED); + return; +#endif + + KeyMaterialDsa *keyMaterial = (KeyMaterialDsa *)key.data; + + uint32_t keyOutLen = + sizeof(KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); +#ifdef _USE_OPENSSL_ + ASSERT_EQ(ret, HKS_SUCCESS); +#endif +#ifdef _USE_MBEDTLS_ + ASSERT_EQ(ret, HKS_ERROR_NOT_SUPPORTED); +#endif + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp new file mode 100755 index 0000000000000000000000000000000000000000..5976f48434c668156015fe576cdc866e62c05557 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; +} // namespace + +class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const HksUsageSpec &hksUsageSpec) + { + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &hksUsageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &hksUsageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + } +}; + +/** + * @tc.number : HksCryptoHalDsaSign_001 + * @tc.name : HksCryptoHalDsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA1 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC); +} + +/** + * @tc.number : HksCryptoHalDsaSign_002 + * @tc.name : HksCryptoHalDsaSign_002 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA224 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC); +} + +/** + * @tc.number : HksCryptoHalDsaSign_003 + * @tc.name : HksCryptoHalDsaSign_003 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA256 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC); +} + +/** + * @tc.number : HksCryptoHalDsaSign_004 + * @tc.name : HksCryptoHalDsaSign_004 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA384 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC); +} + +/** + * @tc.number : HksCryptoHalDsaSign_005 + * @tc.name : HksCryptoHalDsaSign_005 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA512 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..82fb1b33bb0938042ec4b4a97f1ff6bcc1a33911 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +} // namespace + +class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalEccKey_001 + * @tc.name : HksCryptoHalEccKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-224bit key. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEccKey_002 + * @tc.name : HksCryptoHalEccKey_002 + * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-256bit key. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEccKey_003 + * @tc.name : HksCryptoHalEccKey_003 + * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-384bit key. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEccKey_004 + * @tc.name : HksCryptoHalEccKey_004 + * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-521bit key. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEccKey_005 + * @tc.name : HksCryptoHalEccKey_005 + * @tc.desc : Generate key and export public key with ECC. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + }; + + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_SUCCESS); + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp new file mode 100755 index 0000000000000000000000000000000000000000..91a1045a2b12225de67be56c455c387ae98f5f31 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksKeySpec specForAgree; + + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), testCaseParams.generateKeyResult); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.specForAgree, &agreeKeyAlise), + testCaseParams.agreeResult); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.specForAgree, &agreeKeyBob), + testCaseParams.agreeResult); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +}; + +/** + * @tc.number : HksCryptoHalEcdhAgree_001 + * @tc.name : HksCryptoHalEcdhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-224 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_002 + * @tc.name : HksCryptoHalEcdhAgree_002 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-256 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_003 + * @tc.name : HksCryptoHalEcdhAgree_003 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-384 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_004 + * @tc.name : HksCryptoHalEcdhAgree_004 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-521 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp new file mode 100755 index 0000000000000000000000000000000000000000..3f725d5caa274e3bc7a22c4f0495ae53cb61cd6b --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp @@ -0,0 +1,771 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalEcdsaSign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &testCaseParams.usageSpec, &message, &signature), testCaseParams.signResult); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ( + HksCryptoHalVerify(&pubKey, &testCaseParams.usageSpec, &message, &signature), testCaseParams.verifyResult); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); + } +}; + +/** + * @tc.number : HksCryptoHalEcdsaSign_001 + * @tc.name : HksCryptoHalEcdsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_002 + * @tc.name : HksCryptoHalEcdsaSign_002 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_003 + * @tc.name : HksCryptoHalEcdsaSign_003 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_004 + * @tc.name : HksCryptoHalEcdsaSign_004 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_005 + * @tc.name : HksCryptoHalEcdsaSign_005 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_006 + * @tc.name : HksCryptoHalEcdsaSign_006 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_007 + * @tc.name : HksCryptoHalEcdsaSign_007 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_008 + * @tc.name : HksCryptoHalEcdsaSign_008 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_009 + * @tc.name : HksCryptoHalEcdsaSign_009 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_010 + * @tc.name : HksCryptoHalEcdsaSign_010 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_011 + * @tc.name : HksCryptoHalEcdsaSign_011 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_012 + * @tc.name : HksCryptoHalEcdsaSign_012 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_012, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_013 + * @tc.name : HksCryptoHalEcdsaSign_013 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_014 + * @tc.name : HksCryptoHalEcdsaSign_014 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_015 + * @tc.name : HksCryptoHalEcdsaSign_015 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_016 + * @tc.name : HksCryptoHalEcdsaSign_016 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_017 + * @tc.name : HksCryptoHalEcdsaSign_017 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_018 + * @tc.name : HksCryptoHalEcdsaSign_018 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_018, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_019 + * @tc.name : HksCryptoHalEcdsaSign_019 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_019, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_020 + * @tc.name : HksCryptoHalEcdsaSign_020 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_020, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_021 + * @tc.name : HksCryptoHalEcdsaSign_021 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_021, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_022 + * @tc.name : HksCryptoHalEcdsaSign_022 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_023 + * @tc.name : HksCryptoHalEcdsaSign_023 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_024 + * @tc.name : HksCryptoHalEcdsaSign_024 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_024, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp new file mode 100755 index 0000000000000000000000000000000000000000..561acd9a402d1d6d2bf2bd3535b9f7bebaea2f01 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksKeyDigest digest; + + HksErrorCode generateKeyResult; + HksErrorCode hmacResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA1, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA224, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA256, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA384, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA512, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, testCaseParams.digest, &message, &signature), testCaseParams.hmacResult); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); + } +}; + +/** + * @tc.number : HksCryptoHalHmacHmac_001 + * @tc.name : HksCryptoHalHmacHmac_001 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_002 + * @tc.name : HksCryptoHalHmacHmac_002 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_003 + * @tc.name : HksCryptoHalHmacHmac_003 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA256 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_004 + * @tc.name : HksCryptoHalHmacHmac_004 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA384 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_005 + * @tc.name : HksCryptoHalHmacHmac_005 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA512 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ff5c385b56ce25ed0c30f42b7265fda3a18e7873 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +class HksCryptoHalHmacKey : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalHmacKey_001 + * @tc.name : HksCryptoHalHmacKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate HMAC-256bit key. + */ +HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Level0) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + ret = HksCryptoHalGenerateKey(&spec, &key); +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) + ASSERT_EQ(HKS_SUCCESS, ret); + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); +#else + ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); +#endif +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp new file mode 100755 index 0000000000000000000000000000000000000000..1333060d90ec11ca96d0d3772a92f2bc3e187b43 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp @@ -0,0 +1,1251 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "001122334455", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "001122334455", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "001122334455", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalRsaCipher : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = HKS_KEY_BYTES(testCaseParams.spec.keyLen); + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + + HksBlob tagAead = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob inscription = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &inscription), + testCaseParams.decryptResult); + EXPECT_EQ(inscription.size, message.size); + EXPECT_EQ(HksMemCmp(message.data, inscription.data, inscription.size), HKS_SUCCESS); + HksFree(inscription.data); + } + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaCipher_001 + * @tc.name : HksCryptoHalRsaCipher_001 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_002 + * @tc.name : HksCryptoHalRsaCipher_002 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_003 + * @tc.name : HksCryptoHalRsaCipher_003 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_004 + * @tc.name : HksCryptoHalRsaCipher_004 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_005 + * @tc.name : HksCryptoHalRsaCipher_005 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_006 + * @tc.name : HksCryptoHalRsaCipher_006 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_007 + * @tc.name : HksCryptoHalRsaCipher_007 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_008 + * @tc.name : HksCryptoHalRsaCipher_008 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_009 + * @tc.name : HksCryptoHalRsaCipher_009 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_010 + * @tc.name : HksCryptoHalRsaCipher_010 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_011 + * @tc.name : HksCryptoHalRsaCipher_011 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_012 + * @tc.name : HksCryptoHalRsaCipher_012 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_013 + * @tc.name : HksCryptoHalRsaCipher_013 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_014 + * @tc.name : HksCryptoHalRsaCipher_014 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_015 + * @tc.name : HksCryptoHalRsaCipher_015 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_016 + * @tc.name : HksCryptoHalRsaCipher_016 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_017 + * @tc.name : HksCryptoHalRsaCipher_017 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_018 + * @tc.name : HksCryptoHalRsaCipher_018 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_019 + * @tc.name : HksCryptoHalRsaCipher_019 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_020 + * @tc.name : HksCryptoHalRsaCipher_020 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_021 + * @tc.name : HksCryptoHalRsaCipher_021 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_022 + * @tc.name : HksCryptoHalRsaCipher_022 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_023 + * @tc.name : HksCryptoHalRsaCipher_023 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_024 + * @tc.name : HksCryptoHalRsaCipher_024 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_025 + * @tc.name : HksCryptoHalRsaCipher_025 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_026 + * @tc.name : HksCryptoHalRsaCipher_026 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_027 + * @tc.name : HksCryptoHalRsaCipher_027 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_028 + * @tc.name : HksCryptoHalRsaCipher_028 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_029 + * @tc.name : HksCryptoHalRsaCipher_029 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_030 + * @tc.name : HksCryptoHalRsaCipher_030 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_031 + * @tc.name : HksCryptoHalRsaCipher_031 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_032 + * @tc.name : HksCryptoHalRsaCipher_032 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_033 + * @tc.name : HksCryptoHalRsaCipher_033 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_034 + * @tc.name : HksCryptoHalRsaCipher_034 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_035 + * @tc.name : HksCryptoHalRsaCipher_035 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_036 + * @tc.name : HksCryptoHalRsaCipher_036 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a675f29e1f503c3d07240f96211c3666d3bcfd35 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp @@ -0,0 +1,615 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode decryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_001_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" + "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" + "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d", + .hexData = "4af9454165afd9ad50635a7f18858dd3693a9713604971572824fff91cee16fb80169977eb1a91afe8e2ad401e1" + "bcdec93f8c6c5f1398432ee35bd5865a70a1d", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_002_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000bb715e35d0c13b8c2a283017fe1adc3b38d74e8c1870a2ee3c04a25ba9d4ee332f3210" + "8eb7d7c46cf78f88080b64703ba7732592433e8598f4e693d16461ab58284a72a0a9a2df470514369f19fbc7b6a4f0c14e5d2dd289f630" + "e263d4907c3500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001269b10e6509a9be3" + "2083aa742697eda81ceaeb789b4807a6bda1ceb6c661deb59810ddac275d3f4d9a276bc30c65a15fad040d4a41991680ccbf5127548bb6" + "153ef468283ba702d8a13655ab5a6c73b6d3dd5accf567a3231900e138af224641", + .hexData = + "ab3c8dfe0cc42bf5176514913a146fe5466bc317344e073de2c5af055961f04d1cefb563a0c478121f74a23b561a7d6f2bca77a59b5e03" + "669955ce3d320925aee431712eeeac08b96e346d0a59ca94f3780768915fb885e09ce81dd7b5490527", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000a51514cb129c6e19e50eaf764e08067e5720ba300a9031a5a40509d210b0e5a072b7dc" + "6e0b9da82b59bb5c41b0baabbd4b534eb6a8fd50c25a7d9b7b1c7d9e808c5de65a0658fbb353b635dce78ab6d09478257b7e8b5b508cd7" + "5a735ca3944aba2bc8f443cd9ed6b0096cfda268e2fda1462182b313b25f27ecdc4510fc87770000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "016671c4ab98eb16b05f2353e3d8dcc61ad53aec10301df791514e0720235783c8a4285154c1449f3df7bb7baf105b67845b2061b29d00" + "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" + "c27a01672405d4f670baf194ccb4ba87a3c5b1", + .hexData = "88455132d720d77b04128a201f6c1fa234568c368cc4f57d1381316c80e32d3874f5a30f2be6cebbb960ef2a526" + "3801b9c2b98261018b3bbe93e97908739f65be688432a89d1851c45c1d7b02d881db53750795450811f28ce538c" + "f80729ce6f455fc059705e5d120d48280fbbe331226c53fb14293f92351aff3dae32b05d64", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" + "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" + "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" + "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" + "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" + "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" + "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" + "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" + "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" + "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" + "ffdf7059c7ba1a74c5bf6435a8040f175ae1", + .hexData = + "1b0e0e20bdc554668442cd2c319ff6141c40a33ad6fb84faa9d464f489260b0ea97618c3bd5c7a83aed8d8b7943f32fccb66ddeccfdcd6" + "7890efe8a1eb68a45d8b0750c6512aeb2d5ff4d146ed343f8b13def65ac7cc9c7f5ec3b6deaf7f393ece7b29de191dbabfcc1f7ad7e77a" + "8a199668eef72cf46b54a443804f3cccda2864edc45d899070fc9227368ec73195cb4822509653c822a73d0200b0470b9b70aa549c16a5" + "2d43e5ed3975f5762762949590e7d27849939590febed7c0e39ac57b2bfdcb982cec8048de669d2c00095ca8aea66388f8be1403fcba33" + "754df4343ce0b7cbab26f5b43f595c9abe50c79a6876167fe652bc632cc1f341e1e21f8d", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_005_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" + "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" + "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" + "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" + "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" + "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" + "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" + "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" + "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" + "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" + "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" + "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" + "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" + "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" + "68a938c5f0c4254265ae72f54938268021", + .hexData = + "51873b08dde7e0c840d341d0785a26d4f7fc5c4c8cfedb2fd8e0537720a8b680205d8068d37d0fccb8e3825e73aa33bd0daa911a1a1bf1" + "5fa4d87cb900600fb5914d2dc8f6b7e00497abc3308657b00fee8505a3340011f46817f8111bdb839888ed1fa2e9a9f8fad9480557a8fd" + "8d49d255e3b01e5fad00233a65605fda776909338fa3f806513ce02d535ded88170721d4635c03c7e2907fae9227991abbcaffc28cc462" + "4918571861aaf53796f7716aebb946051b312364fe358a6849685b87bc0a5373cbb95760001a958fbfa089df9157b66721fab189df5308" + "28292409494909a8b3f3aca7d909c88bce75c1a41cc3a639f7ed4cd018b6187faefa4b1c8362e754b2571b0b7f8d208ce81305dcb35d89" + "e5ec2eb8e3a5690c26c8eb9b84ebd9b1cb3c652f2e70c5a3d7621925feed1441d88a31b4e2f927c9825409ad4396ed81bdfbb67bd2892a" + "5246e915663e0210c0abdc0ede5f6021d37561893e7342a30c0609c04708be29f13737b98d1969b7b56c48d84ab6d854731bf299379e", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_006_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" + "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" + "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" + "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" + "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" + "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" + "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" + "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" + "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" + "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" + "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" + "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" + "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" + "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" + "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" + "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" + "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" + "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" + "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" + "62a124488021988f9d71ff68f2028a19", + .hexData = + "8b8c55416c4fb052ead30f042c39e66c512b002c0b38a4fb08f0ebd7c78b2f231b16793e857738b0b1a6d6d198a95aa1acf8c85e997ab1" + "2e1c6cf1fdaf2016adea6d6b54b972452154566b1ac786c71ef199f9e50ae35dbe5196a12b0bcfd746cb72d93eda34418f3cd73189acb6" + "03a4ab6f05d0f08318c8b48128e23cdfff529eb1fd9c6a3a64171711981d568bb93166f68d9a8eed44a8040bf0f703853c337dcbaddfb4" + "b48ccf4a2a0358574182ecf4eb3d9a04a0e3c64409be0b60dd4165bad4fa7750197201c5dbaba642e713f0c776ab57ce4788f4f7b8ea7a" + "0e0a562894dd7624bef236ec805ed0be81dc4e0cace17e00a6afca23364d2e1f868c8c7daf70b66ed646a889f9ed1880b3fbd8d4a1b33d" + "325c76f83b16e7594597e38ffeec60013456d433eabfc0cfdf0f863d90559c9214f84aa60d947850858940606a1d9982c9d5dc0f3952ef" + "d28b3d49e3b2dbfa117dde77382ac541f0a1e5156a528a393ce4554875216bc254fe9ee1d5b5cb693440eaf00adb4a1e1537376480b448" + "9a8e717a5d565fcadc561e14e1a74fbf779a6348ba1ff4548c35cddc49829b9dd4611fc38ac80b840fb94411982124d8ffa270825c3ab8" + "63c732cd4b81db68fcb901370b8ebf0075fc8f64c8faa17ca19ac7fc0fef63510ff2dbebb0954649ac380bdce1657b4ee32470c3077129" + "afdd319c966fa39b05bd8faa05a16a87f1", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000a6a29490a5a6b309192f7571daa7cacce05dc5a5af6e4c0648ffc3dd72704651c806ee" + "0cb61afc2f118bb24075a2f303cc548bfd9fea2c3dc945d5d976457ae10000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" + "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599", + .hexData = "0716c17114c78dc6000d72b612174e6ac6b42cc2b7aeeb3651dffc92741a6396360368cc8a3f43629a78ef56231" + "89708b4cc75a244c46235793c2d6bfe1dbc06", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000d056e8b387700c781feb01097ecd9868c32af0cea33292634b2b0027117b75af0ebdb9" + "6172c776ef95bb7c3dcfa6126858e6fe69c87e0ed69dcf81e15ebef50f03fbaffaee527c291f3740e521730271eb3b63f4057cba780c6a" + "c8520816d79300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001acbf7361f12a5a5c" + "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" + "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719", + .hexData = + "3d6968c44be17c9379d982a739429424e24c30dda87732d9858efd0ed43a43d2e5abad0bb2a84254700b6d2c3f41a7fb6d9b726439dc6c" + "735cbb8fda5061051e5f2012f7960919de7a4e7e4b8c53aa39584ae1df649e33a951e6e1c5089aa251", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_009_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000bc294482ddb7abe39a04a31b8410e9115691e8cdedc7aa060a63977d55a6f924f8387d" + "93bba101ad7351ad244baf25d19a840dc975409801fe634a603cce8fec3f2c40db3d2b6f0053e4ae0c073f5d21c9632e4d3a61f4afac89" + "5367e58eb6fc9a723e75f14a8dcd7dd210644427d9d26da3cb88aa085e9d3fb74bdeb16d4d250000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014fc97801be1eba46a2f2c06f548b0f2988fa0a2bf85e281cb39f1387d4201f99ab9fd8b02269dd9a3d422f172af8b422b350b7bfeb76" + "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" + "70960dc0698a51f3e03211fa43b3a4f9336141", + .hexData = "29bbe6754eba61b5b2907a73f03d4c3d21ec3b15296f78cc12bc870eaea302e2f1f0703c53d9a8ead057079affc" + "0e1bf7b740593f826f8b2e78c7f580bb311c04bae6005576a0df747c7353b827719ba551fdbc40209733b2b4049" + "de1fbae809ff6d548b53338bb9259699caed4281e2a5f10ae9247436ef9b892ba2d4be4fd7", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_010_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000ddf3e9c6589658e5c124a49d473db529e8eb08b99c351cf7c5d502f64def9752d4ee88" + "d942cbdbc7fb46eac9d9b9f9b309fbffa99c9fe05363b2d5e71c2d132bc83d74f0b8441266fc2f6f0462b54fa0ffaef92bb93cec2d1805" + "9db40ff9d579f7980c08cb9a30d076d6ebf50f4166514bd00cdf20ca042ddf13581feddd32b15e8508f2b185f4e6c77217c5096a9dfecd" + "5132ee4ce41bccd3faa75abcf1014e5e27328d3a1b08e56c33d5f5f2fe8b8f232db6953a337bca29e2726165732c8d1aae10a6e9c60ce5" + "4b2423868e6d024dfdfab45fbb3d589d06fb8f55564bdc2bb07c1c84cf8c076045706b36e6715c4dc8cd1f4fe751de77b031b5bcf7cde7" + "41000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000001000151ac53b5fd1b361335837a5fb5bb6b52c4b6" + "d83b14d42698b65faffb5aaa7390b37223416f66fcb5162dfe6fd082b2f3c314cbfb69fb1add14aed62f791acd172b54121812765a1f33" + "657100b821e7ef62a6cc61de842094676689a59ccb5e56c75957f45497a4a6d1543cf7ac69707131e89913f248e448ccf19d58027b870f" + "361c57bc60e75da62e75d94b7e42c544e7ef183fd1935f0ca8d637e18cc4acae0e99f8aabbf83c968460b5237eac3271f214fd10580166" + "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" + "f7912bf772c9039385ab0a81c0186bf91001", + .hexData = + "ab325c28d67e141d0af060d14d6f51858b7ef237756d41fb26d3ee4d64992fe2dc47028a7295da19b751fe3023399ac2b6fc368b479735" + "e24812ac24e4c35831d556718378b502832ad8aff79eaf1790fbf2f173f6eea2f330fcc3b6463737a63c443ab9ced5f4bd0d07bd230579" + "27c14d45cef42b7f4c73e92d61ba4006974259c6b47d236ed7076267f8d02204d793b89f360bb890578392ce23baed87998c1f7db074cf" + "4a781ee4f7d273f44b67e541d1b79f50ed9be0315c64cfd6636e07fc02285435b765d612fa6d608a3e29f2c943ae2e13823021439c4b5a" + "647f8db556b41d3590983fea6dbb05ca140ce16ccf209978050ff670ecb0c1227b04820e", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" + "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" + "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" + "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" + "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" + "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" + "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" + "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" + "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" + "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" + "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" + "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" + "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" + "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" + "94019bc2c4fd028ccca7dc4e56e657f931", + .hexData = + "06f006e44c76a83944663b77495304ed3cdbe478aa2132eaa1fcdf0b690a791b240ca9f4771a901c9ac5f1fedb9547260d20037e339331" + "21f99b022c465f9fcea0c3b5789c79c57d5ae884104a914cf7f0d44aa37e5602d029b6c7ad3c714fce96b229eed0aa51aedf7c79351ec6" + "9025cf32ea4d32f7e04b59530a4241cf823bf7a9cb1e6ce877970b0bcd016b1db78d82c8ab53c114177d5ee184cd193d59244a6e575353" + "9f25e7058b1deb48c0af84ae2402cef58c454575eb07c5be0516881c0699d7870a00d8d0acb6fc8775bed70be9ca0d040ff82017e22ffd" + "38571988659480cc29a41163940d7fa74f57dac386a55334d4cc7be312f499cb55c19389f92bbe2b7200ef1218323efe2793981695e527" + "3253ac14139b9dcd27c2c216b7a284fab2b7f4fb91ec97bf9974b214af1f718efd2973af9cc1ce4349614e6131b1c39a5e6be4b273a268" + "4c706f054c87a4afc64c1f80293143772e010482b61dd028612d1935d7c372bf6236a4863faef090fe10597bf91fe2464bb60b0c18e2", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_012_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" + "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" + "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" + "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" + "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" + "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" + "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" + "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" + "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" + "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" + "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" + "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" + "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" + "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" + "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" + "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" + "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" + "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" + "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" + "083678709efd4b63e5f0a699ec19e949", + .hexData = + "2769734972944c17d96fadc2c2ac2295a0b0fbbeec6bbc866ec2f4b49af477de0be17ce35d5568780ec74400dfccc7dfcd53a5ce84c758" + "02bb3e20e66dfd2e9f35df0e94efab95e5e946bd203865abebd8280f0ec2a072e307a40ef7828d0c5c9149a1c292bbf25f1e5682e78a1c" + "f13301b830131c487463d04def399b5d04add2c145293c5903424bdbca2ae7c7010383e81c7b1371bbcd481e19a4234074fcd1d369de0d" + "c0b9302577f4187fc067901cd0d01c479aac5817ba0bbf49da87e8dd9b0e3d5a188a4614f4129084b3712c7a76434fe947dc24388a8094" + "3202c125ca2095378d7cb6ab17767387acf8dd83aad89bfc538bd09e69e010b9e568dc361301bbfba1d38a69691b0b8e8dfb0fd6704779" + "5d32239295496ccf9a0d397ef294a96a4665cef6206f20ac400039b2217e16c8ad9497509bfb506724d4d6d1564e45defb035a488428ea" + "9748400c97e169bc1aee1833f628e37c42ed840d2845fd5dc7217316eb7225ac64b6b97a487448f3aa2a5b2d3a9a484bd0aa9eaef58e00" + "04b83610089129f8d7a66507643a5d99a5188e2bd0bdf2caa1b0b93d198401f5ca2859b5286a351e41fa1ebefc64d0213e957387cbd8f6" + "8fce198134a27a3ee691efdd9ac83eb870ade586b28f9ca9e2758c21cd8d2fa18a8316e78bdf0cbe9de48416beb60be675662429e7ef0d" + "4ee157e6fd03dc292c7d4cc39b6cef7b09", + + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalRsaDecrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText), testCaseParams.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaDecrypt_001 + * @tc.name : HksCryptoHalRsaDecrypt_001 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_002 + * @tc.name : HksCryptoHalRsaDecrypt_002 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_003 + * @tc.name : HksCryptoHalRsaDecrypt_003 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_004 + * @tc.name : HksCryptoHalRsaDecrypt_004 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_005 + * @tc.name : HksCryptoHalRsaDecrypt_005 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_006 + * @tc.name : HksCryptoHalRsaDecrypt_006 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_007 + * @tc.name : HksCryptoHalRsaDecrypt_007 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_008 + * @tc.name : HksCryptoHalRsaDecrypt_008 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_009 + * @tc.name : HksCryptoHalRsaDecrypt_009 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_010 + * @tc.name : HksCryptoHalRsaDecrypt_010 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_011 + * @tc.name : HksCryptoHalRsaDecrypt_011 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_012 + * @tc.name : HksCryptoHalRsaDecrypt_012 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_012_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..56a6b42d059f188b29d8f1adb879237e65940a89 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp @@ -0,0 +1,606 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + HksKeySize keySize; + + HksErrorCode encryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" + "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" + "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_512, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_768, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000a51514cb129c6e19e50eaf764e08067e5720ba300a9031a5a40509d210b0e5a072b7dc" + "6e0b9da82b59bb5c41b0baabbd4b534eb6a8fd50c25a7d9b7b1c7d9e808c5de65a0658fbb353b635dce78ab6d09478257b7e8b5b508cd7" + "5a735ca3944aba2bc8f443cd9ed6b0096cfda268e2fda1462182b313b25f27ecdc4510fc87770000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "016671c4ab98eb16b05f2353e3d8dcc61ad53aec10301df791514e0720235783c8a4285154c1449f3df7bb7baf105b67845b2061b29d00" + "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" + "c27a01672405d4f670baf194ccb4ba87a3c5b1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_1024, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" + "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" + "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" + "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" + "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" + "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" + "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" + "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" + "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" + "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" + "ffdf7059c7ba1a74c5bf6435a8040f175ae1", + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_2048, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" + "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" + "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" + "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" + "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" + "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" + "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" + "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" + "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" + "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" + "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" + "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" + "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" + "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" + "68a938c5f0c4254265ae72f54938268021", + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_3072, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" + "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" + "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" + "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" + "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" + "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" + "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" + "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" + "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" + "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" + "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" + "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" + "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" + "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" + "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" + "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" + "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" + "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" + "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" + "62a124488021988f9d71ff68f2028a19", + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_4096, + +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000a6a29490a5a6b309192f7571daa7cacce05dc5a5af6e4c0648ffc3dd72704651c806ee" + "0cb61afc2f118bb24075a2f303cc548bfd9fea2c3dc945d5d976457ae10000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" + "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_512, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000d056e8b387700c781feb01097ecd9868c32af0cea33292634b2b0027117b75af0ebdb9" + "6172c776ef95bb7c3dcfa6126858e6fe69c87e0ed69dcf81e15ebef50f03fbaffaee527c291f3740e521730271eb3b63f4057cba780c6a" + "c8520816d79300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001acbf7361f12a5a5c" + "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" + "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_768, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000bc294482ddb7abe39a04a31b8410e9115691e8cdedc7aa060a63977d55a6f924f8387d" + "93bba101ad7351ad244baf25d19a840dc975409801fe634a603cce8fec3f2c40db3d2b6f0053e4ae0c073f5d21c9632e4d3a61f4afac89" + "5367e58eb6fc9a723e75f14a8dcd7dd210644427d9d26da3cb88aa085e9d3fb74bdeb16d4d250000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014fc97801be1eba46a2f2c06f548b0f2988fa0a2bf85e281cb39f1387d4201f99ab9fd8b02269dd9a3d422f172af8b422b350b7bfeb76" + "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" + "70960dc0698a51f3e03211fa43b3a4f9336141", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000ddf3e9c6589658e5c124a49d473db529e8eb08b99c351cf7c5d502f64def9752d4ee88" + "d942cbdbc7fb46eac9d9b9f9b309fbffa99c9fe05363b2d5e71c2d132bc83d74f0b8441266fc2f6f0462b54fa0ffaef92bb93cec2d1805" + "9db40ff9d579f7980c08cb9a30d076d6ebf50f4166514bd00cdf20ca042ddf13581feddd32b15e8508f2b185f4e6c77217c5096a9dfecd" + "5132ee4ce41bccd3faa75abcf1014e5e27328d3a1b08e56c33d5f5f2fe8b8f232db6953a337bca29e2726165732c8d1aae10a6e9c60ce5" + "4b2423868e6d024dfdfab45fbb3d589d06fb8f55564bdc2bb07c1c84cf8c076045706b36e6715c4dc8cd1f4fe751de77b031b5bcf7cde7" + "41000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000001000151ac53b5fd1b361335837a5fb5bb6b52c4b6" + "d83b14d42698b65faffb5aaa7390b37223416f66fcb5162dfe6fd082b2f3c314cbfb69fb1add14aed62f791acd172b54121812765a1f33" + "657100b821e7ef62a6cc61de842094676689a59ccb5e56c75957f45497a4a6d1543cf7ac69707131e89913f248e448ccf19d58027b870f" + "361c57bc60e75da62e75d94b7e42c544e7ef183fd1935f0ca8d637e18cc4acae0e99f8aabbf83c968460b5237eac3271f214fd10580166" + "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" + "f7912bf772c9039385ab0a81c0186bf91001", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" + "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" + "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" + "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" + "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" + "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" + "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" + "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" + "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" + "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" + "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" + "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" + "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" + "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" + "94019bc2c4fd028ccca7dc4e56e657f931", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" + "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" + "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" + "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" + "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" + "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" + "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" + "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" + "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" + "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" + "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" + "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" + "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" + "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" + "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" + "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" + "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" + "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" + "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" + "083678709efd4b63e5f0a699ec19e949", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalRsaEncrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS1_V1_5) { + outLen = HKS_KEY_BYTES(testCaseParams.keySize); + } + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + HksBlob tagAead = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaEncrypt_001 + * @tc.name : HksCryptoHalRsaEncrypt_001 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_002 + * @tc.name : HksCryptoHalRsaEncrypt_002 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_003 + * @tc.name : HksCryptoHalRsaEncrypt_003 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_004 + * @tc.name : HksCryptoHalRsaEncrypt_004 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_005 + * @tc.name : HksCryptoHalRsaEncrypt_005 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_006 + * @tc.name : HksCryptoHalRsaEncrypt_006 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_007 + * @tc.name : HksCryptoHalRsaEncrypt_007 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_008 + * @tc.name : HksCryptoHalRsaEncrypt_008 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_009 + * @tc.name : HksCryptoHalRsaEncrypt_009 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_010 + * @tc.name : HksCryptoHalRsaEncrypt_010 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_011 + * @tc.name : HksCryptoHalRsaEncrypt_011 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaEncrypt_012 + * @tc.name : HksCryptoHalRsaEncrypt_012 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..43bd50fea2c8f5775b2504d01df280cb66b54a2e --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +} // namespace + +class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalRsaKey_001 + * @tc.name : HksCryptoHalRsaKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-512bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_002 + * @tc.name : HksCryptoHalRsaKey_002 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-768bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_003 + * @tc.name : HksCryptoHalRsaKey_003 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-1024bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_004 + * @tc.name : HksCryptoHalRsaKey_004 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-2048bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_005 + * @tc.name : HksCryptoHalRsaKey_005 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-3072bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_006 + * @tc.name : HksCryptoHalRsaKey_006 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-4096bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaKey_007 + * @tc.name : HksCryptoHalRsaKey_007 + * @tc.desc : Generate key and export public key with RSA. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_007, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + }; + + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_SUCCESS); + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..94077866444474fcfb8aa7d9556b19dae3293d0a --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp @@ -0,0 +1,1683 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode decryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "070bd81030f33310b12f3a83894c16ab23ebc6d9843a71988807874a465eb29f06042a5e9b27f16e998815e1bf8" + "a5f55b48750632202693fde21264c21dedd33", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_014_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = + "35249280c4a155024e0f64c0c26ab980d1ddd9fa05ee8c4ad8122f70647c0c608b63c3efe68dde3e07cacd89398ec1660f858bfb1082e6" + "ed82ce54c14a7c6927a229c0b619d0e909c09daab2dae24a809139496217307fb02a5d4dea9b2e0074", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000d10cdba0a029d15254e1b98a1ab3fe28387017976d817ed229a88e521037451768a681" + "bd6b8944d1efc6be41913da3dc8cf42cae0d0b449e2cec4df0537b1702cd9a79b8394175c0474e96fdc7d26616c268059c4d01bb6ffa70" + "c12fa591e40093d988fe0c1d76df2d5999827cb12e7b287d537d477a7a8dae6ce9e6a1c2577d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "010b443221f9ffc6f434f6e554f81373431fa78addf25ce444d751ea39a9fe108f2e68aadd568a53572d20fce7f3b7eab8dc2fdca894b3" + "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" + "5b83ef84097f2112e64d11193da5dfcfbf9a51", + .hexData = "752b367cad05c09718da9077ada4062a3aca68a63c92af640cdfcb6c409cd857df9092bfd1dd14f894fde120434" + "f2007e67d10acf835c4767be6b596840faf88a706e95f085d63b46694a5ed492ca36c251636af3839eaba1a7714" + "d796a686cd94afdb96893f04fe276d681afe036708dcf3a8bd7516255dd8042eb9517e9584", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" + "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" + "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" + "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" + "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" + "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" + "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" + "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" + "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" + "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" + "adf95c1f761b56c8ddf2e78e532861cef681", + .hexData = + "c303489c1204761cf6e3ea1d4ebbdd77933dce5acff16594564a9b1c41a5690a04777814c531ff8f0a0112182b0f96c627e3756d4b2756" + "d7d1f8a2ec8c7cba4e0cb29d9cb8edf343e5633715297a882f4a864e4543b30063018ce01358639fdd9ad452152fd4d938f9e680b23e7b" + "27fa85a23c027c7ca95498c3ee2f8ac0bbeec11c0c8455584f2f583027054b39b92326f018d2d68093b99cf741a2985e8af712548eff72" + "5b5c707172458ed73b6fcc98143fd1bf6ede2885a9ebe10e76b215d4554d6cc9b04cc10c76b6a3c4f8d0dd1b67fb439b9dcf4fa2cc59b3" + "786a4f57f328645d20d8a3da2e301f42783f453ae93c622173d643516c8484d024d6b5d8", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_017_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000c50e4fe8739a73a3627e504ffd323bb95057417d2b23fac0939c6e3c43c19450b38733" + "19275612866f0e8d349585c17bffa9c13389975916f2235161fca6a655b4c0a3c833789a18a9add01f837da762b5acdf29f296324b4d5f" + "7f586f900566d949f4784b935503b4105e2c6e83d43d6d17e07545eac427be17f0fd7b08fab210f38bfb405ca524877d5c039505a0a9d7" + "c2e24e9367a8a13e2fb9e3e1dd7b72936737b0590ce3cc9262284ed041c2b362ed3b617bf879256e69be4357c027dc66d5afc0a4d35a2d" + "cc6b42344bf55b90985aea8d2604af1ad404fa8dd9014c21da00a2587c82f97045b8be3593a41d71307f5b3295964257ab8d7ab8521b47" + "29dba792af69655296577ca175d974e64ed33881c905649b8a6bbb13ac1cb1cafc6ad61af81d3a0813eb1107d0d953607a1e99657de527" + "c108ce22c06f8585751f071efd87e7e874e01c17714ce73c2b619594119030f54f9c88158b8d64ffdbde582c3340898c18762458bec67b" + "a306aca31268accd72a4382c6e06b35a01f673000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100012ce1e0a3724938937b288804600824004663496048062ee3d3fb2a4481ae42a8caeb3d613a" + "4b6976c32ece4caecdc34f09e15146faccc516ebd9cd7c82fe361e8947e346032b31f5f217cbb291d179e18abdb02aaebd35015fc3238f" + "3201dca91b4eb3e6fe57b5625d8de8d537eac0d9a8d26a666ba158423112e4e9e72f19629b67cd7751a6885ab49d81eab2f3902f7f1c3d" + "4d665792d9feff01d8fca5e4ab2915b6626d35f960abeabd818dff9c681d5d294c3fdf4d409050776c813d1c16b9ae28a78057a4a47e77" + "c62071a0da7d8cef186a98f2c95b16394689534726d18fa8b0526c40d64bb13f579532fc56e9ff2fdf95f0df3ab8493264ed098cb57e8c" + "fe9cbce24a5bdbea355ede53246798c79599d7aee1ac380ed8ee77f08276c617fee8a8989c116407e8d7a481ff77ef32f7405b5736b36a" + "593925cf15c3da1965f84eb4153a7d557a790a869fb99290dca0b4d6a97bc0ed32fa41eba3a27b9379e3f2b140e7d1e0a315af6561c5ff" + "1c894ad34cb998b6eeaeec5d3785bddfc1", + .hexData = + "444665d129abd103992a5953066d4e7a6bbe9f6132d2a783db39c665980b5b89c9bb06de04fabf8aa1d7d2a5ef34d55a336200632a933f" + "73f3f9f84ca1cfbb6e69986c128919dcacb16f741b2e0c90562ed3f410e4419411d49650b73be9e910705cb69824286640debf3be88e5a" + "c5cc300b38575933df66b9c51907e2e997b531a486bd320becba1992fad8b099f6b110c125c3559431f45cf0ad9ede5c33087e4b464905" + "8a9e87bddc647eb02bdc39fb86f5498dbd3a317bbf29d02460a0991f9cfd615f0efffc1a66e5d48af9aeba2702ec7c3c0dd48a1987f333" + "5c06208ebdf0c0817604137f9c67718faf301059a2be8da7ac43663410e44362e28fcc0f17de1af251c7145c944c1e4bf29d7989d5805b" + "f971ebf021ca7e139f0a1f946636b17e2638f3b59e04ff613c20fe58f9b07bf2c039a27aaf3da4cc788effbc4214f7d3034e1f32ac0361" + "e5a7f88871be506b43aa5ed24e42ffdf3174e89d3a3e7337389d3e017ee76005154afae1230993ed1dda61194ef4fb9ade757d5b27af", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_018_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000b3166774620460ff0b4fd912c441a184527d8b6bcf1d4fe22791bd0a79b9cdb4afc944" + "532e948aa190ec27869df84384f0921abf036181369db2ec71011f3f2ea1b1a0f8521cdb75a47e1051e68d3220248b9e68303780247fba" + "99610d7309a99087c6da95a0f3bd5abdf703693bc7285a0a30944e132015370f9d263f44b8b2d05ed32470096eb6c7309e6c62d74cf99e" + "72ee94e8e1bbbcc902935762c6a5e3297e4766fc49867e7768f40902d87a219d92c196caa030a206ab75c02a4fbc4d0803d082fd328613" + "9315489f52b591caff2827d70d8839f47fb4195dc6036f3718987b56e6c772a30694cf983671ad6b93e1ec99ff94125a6268b1e556671d" + "11d41eeaec4c5e642534243dc5f4edd64190dcab9497298d8101ed7c3a97b4f28c892cdb2e3adc67bca83862429d82e8f6c40b72d7dc39" + "1b214c09da284a7aeed2a21914dd0aa3ffa0c97800b8c37198e92a5ed1c12788c9313d3bddf5436cf17c1e481e7613fe8a04cb8e5c14f9" + "8c450f4df4a3f77e548615adc6face54baf5f60a140759ad341aafe0187d9f05745f094b547dc4bb3ad5b2be64dc10e000e555c7a09282" + "e7ceeb8d99e1fbc64e57409f644fe5e877735695222347ce556fa340188ed74df9ebb26f7205206a94b9eba96da988e13ad273b931a9f7" + "6e501f371e789cb2a1249056076e50091949bb9ace7af104cd9db3e03d832a4c3e6fdb9c87000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000170" + "d46ab5ae9367b1082574741865e926fef9cdff4c6c014a50f7c70c7488958b833ce0e92f6db2b1fc266cf8a94a22effcc970446c12e05f" + "d29749d4208ad939bdf1b5a2fdc8e49387e14cd2ecd8847e2fc82f33213db664487cfde96199daba942e97205c291da76d26461c460ebd" + "7934d13aae154a836a1a58a1ffd8d8a92d2f8eaea4445a0d00e71a4095b4e844bcf8111d33804dc80436f8827009f171ce5ef40a745dfa" + "ccdb9ccbe9044c60ab01c6cf115cb9a8973b5dcc64d17f56e121ff2cb80fef0a07e30945dd8d5384c5a8097df92bca80cb52b9aa7458da" + "4a8ba540bfc0e58d5c976312e06ab2518ae961dfb7f56348dcb77b6e88db9bcc06070f871c5f38d10e16c686e51a78a7d54a78e7ba0d5f" + "a5c42c4a401529890f5f697ae567a0e5583f49e73f2ee735dba5d0b15df3f0195a48de70120eead966126f161bb57d770cff988500ed1e" + "49739298692a55764756eb3930ddcd035f36f121b242d21bb4088bf176a3a98045e25ef9347d2a2438fedb024765d80b7a6b4d5b0edff1" + "dc96854afae97c3b6bb40793f78e93972a8080b87934ef9e014087ad5c794dfd6313cef45d72d9be592846a5c4414b2570de994b467db7" + "8f068d0886fc1d67a36f80f556b5913a55da31fc193718e74dc3275c224875eecad8a353183244c4c73c2bb6b96a5ce84c5c8992b43eb7" + "2ed71af821a658f473f0a3a283f40d41", + .hexData = + "193b8cc1eb7736b40ceb90c48a184a2bd7b02759e0ba6f167dfeccdbc09e40ab1ab7e7940b073951892696e5dea1325da7662d61e4b888" + "b395067dbe3db7e2fae21c8da725b841e7d05306a44a69736d4003ee18eb3013e9df01b78205e9b8d789f670f51d7e425c0f63355c615f" + "460d066d52fc747eaa23f8ec411bd22ea75db5236035b2805d9e356cb8f694a4788dc549db357cb7e914f55ebd9d1b76f272544adb71e6" + "6d285c8cbe6bd6b2f835ccc8f5c80f24c19d0e5a50f7c7d158fe354a5d267bdd217359035cc1f0dc38b0c5f40359528314a5129b709a9a" + "9b4d3291002aea22da98eda77e096128854f7664572a61fe1f6615fd0c1df1e3cdefef189642bb23fab3450f6d4bae77e9a3df43e08c62" + "ebcfb1d2d6f10d8bd6b2f4ddfb3bd4a143d61cc1d065ccf45de5e330fa1ab2f8c6fbd3753549a7cd8bd8e26c88ac21fa277a106f7f9e49" + "45b87374f04e73214e4c6ce61e4d77643e1fd8c13ac0e1b93e55ad2b574e9185b0f490dc0cf8858125b505edc330f91bd44bc14f74bdb6" + "66e6df9d26bf4c45e414ba569461f3f53915a5b80edb59254e6b786fb24728b4c08180bd912b037a20ac9a4d795121eb7bdbf38cd36aff" + "4adc1c693b51ef6d5d85395ba16f35eca51317c9ecbe67b7b583cb8006c79f51e20efc2c2187b529aef5fdd7cfbd2c9cb1798f43883e83" + "70bf2e4c27a89d718536c06e449b934b41", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_019_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "aa7b5d9919b61a4d1a7e7b3651c17a758e995ec9583e9d2b5ef4121b45d8f9dec009fc03b19e4527105ee1d0cbd" + "1b3bd66123c12899f1e425ea63e69958e6dc5", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_020_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000ac66380f18d9dab2188de40e6bb622e2da123e08add16b7c5dc260dfbfe7432c390698" + "e3bf34e7e237c0777e4bb10a29ad8ce41172cad65dfcadf25c8dbf9b0e9fcd62d5a4b7967199151aaf97df9eaffd0a2f96cf324c2a6001" + "7f5f29d59dc100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100017ac81636d2591dc3" + "676f6eb3c28ca64df047bbbc8ca6b0a99351039377662a560d8b204a5b7c3f85c27525e561dd05c1bbdb5bc9bddede40e55397fc15034d" + "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001", + .hexData = + "8e5129736a8e1986fcdfadd0393f8aabe080823a7b4275d0dfa4d9fa32b9e05720d957130acf4c8cd512688d447b8f84cfe7f1b4cb4371" + "e2f988ee2774b280de4461f40467d2e03e86389547b5066e43f81e2da8e5cfbd9aa0c2f16fdfb618dd", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_021_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000cd1a15f15683bc8bb38041d407aa1499bffa2831f94f61ba607a37da356a664e0af5ea" + "01a43052b1b93221208764c02df86d69ee2475192b0bee0dd08246a3a927df959e3e2ca68558e3e8f82c1fbc231524f3d78bd2ad1141db" + "4dbf5800a031f254a9f5eca58169bb3daa787707863d0f42a0a868c1cf882c995965cb4317dd0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014145f0ffca71c87a8958e31a508a1f5e430ba0e92e97c5d963c4e1ab8f5e5a4ab2104b35d484107d411c2410cf261047510db92db1ea" + "9664edba0829789c748ed96740a56894f7f085ce43761b81e00738337061bb7f7fd27318c558f4deff8160c071c7c91c47a3e01950198c" + "ff3985125a1ae69abddb80834bafc33944edc1", + .hexData = "7d18be21fa944e51759c94e1b276d5051059e2b759a12090c6d22b264d46f00e9d52d3ddd5878c381c00c675ddf" + "e08f48dc47b6c8e01a759dfc2ead5bdc72afcec8f8cd939dd256b619cbb98b5cd3e387f048b7ccef09c5c1c8004" + "0e59760f64300ef08739e22fa7e272fa3c5ced217b6a7371b435cf9c169ecc1a1d551fc05e", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_022_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000d44c2eba9c805a2e00397ba68b54ded3d626b02b93d72664f97e023ecf5d4974388aac" + "ab0983529acc1302beef7975cf9db43a4a422b258bc3db75fdba50fd67bd009a44a248b712638589c6d5115aeb8b320c04401400c3a0d8" + "6684337937ff2259330c06dfbd652497fbdf5722dcc8a4d583f59ad1a02eca4a964516a23a06c4398d4edd2c977e7b85d41f303f62bfb9" + "3ff65e9e837e8d3c6f1c9c9d067a0df7c36a0c196349d2cfc1d82c5daa60935171e42754447ce60328abbcbba6078c39ccda078cf88adc" + "1dbfbc645a401fe386b57b5edc94d5bc8fc7e2c3cac6608fe8d91e69ea9fb17f6b7b42ae794fbe82e12cfa4ce60a11de5e83c315b902d5" + "c9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100014aba8a545bd47e69e4e0571b37be67355013" + "8c3dbaaba83330f35f1cf6e7527cdb8e4cdb63dcdb0dec39e0e48eed454010b629328c7a1d9c461411437ffb144818ea86631470de2855" + "e9e2a69fc79d267e77de6cfc954df38ec1bdcc59461924f0d54f37b38fbc5e46f44ccfc01f60722c3b9058bae7812817430c0443c45501" + "fa69778115a748a79b89d1e99c7791516a2f7d19114cbbd4ed7827b51ff8caee4dee84f16ed0a1b497513be6d563fc5ee7d0891c523e8c" + "0c0be002f7edc638607ba45647166342b004d1cc7a31a3492d8980b9a3f2151a4aa2cd8bdac7b1652d791e6915730bc9de98ac1a3b5fd8" + "2c26ae2da515146886c78090a7aa8c31ecf5", + .hexData = + "a3f9244077328f00ed6921234d6d9ede1c1d580a8ba7a5f3748880d29011e50e26e1f84106674d07e20c4ea5ff0d6821979f01d86f4a16" + "4e5cc3c3af9fc8bb627beada5686f3281b105f2c5da0453cd75f5ec13d1543dd84dc7a14da3aeb55dca29aa0466f78d0d8e6e223ff5534" + "ad1d638f7f4cab4d8fc3a8b68a83df50102302f1445bf5c7782fc787b6e95ad21bb4dd3b2460dd17447296fa898af7e5b8ef99b43d2eb5" + "9e7b1142cce5e9bbb2181a3a5241572c194df23f2f4242d825bf6ab6d943db161ec879566d0c3b845c57586109a9f408e4ccb6f79ecc71" + "2c18dad3476d283fac34d6513e34e01f9688afe2fca84e00976fd624292aa128b6518dbd", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_023_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000dc3d6c0fb6da1679390202196baa6a999f217a7ed8ba8a3d309bcdff755094dd09bc41" + "77ea6ed014ee412051b2c02f851f32e4400c894ec6da6b510d613536c32f2dbce41d4b9196c24ade4edbde812e8eb2a774bad179c7bc4b" + "aa338fa2cd67d5e6b868b042b7fc0120fcf2e8e104a3dbc35c250fc91e486565e8928d5d047d0bae93ff09d9351157e5a000073935b09f" + "4bc7e5b25e2287f44ac8daed8e0e5db021359ec22acd2a1d374d82d7ddfbedd7ffe6a09e52fe8d23a751665fd8b36a456fea4d69900a7a" + "623d92c6a28e56d80561e3123a99c49253058177cff12a06c8e4d77563f0367f5ebaa8f5d71750c721fb6a6dee9d28a97c7474692f60f5" + "528f3a1e02234c93fd895e62f40a9c44ed62cf37c52e1c4f582350c6ca7991a6468cf4dd75b556cffb09c6b69c4719d00196f4bbe1dce1" + "204bbc5a673fc81fbac0a8e2fbfc7d4f87ef3e1a501da79226ff984e440731c7a2d8882aafe3d8195dfbcd8c8665e9e1bb334fc9b64ec6" + "b22f38015a9e797b3a509b8efb44541344a64f000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100019570a40361aa47b7878422528768c21e6d08b56a9ebaac946a883dd60a0f5c834358d6ff7c" + "3626c11d0d59d5b5b98c4502ef704b39766ddaa6584d4e0bd8a4c8fa1949e36b315c9f744482e5f570dc2cf02caf4d987a0ced078a3bf9" + "f28ba05ec5986126bffaf5866c69aad9544562f5a067c5fd6be1a6c7aeede04a98db35f1775cc51537e4878ab61e9c5b888b3c301556c1" + "53cd9cec475deee4ad10a5e47f93c464f2cd8367651d1fea5b4f08542a85f720d179bc8cf6cdeb796342c3f2b0756daf51eda214a3e49e" + "23fa8682ca429d1f5bdb6488baa9595272ceb55517fda0eb723256c50fb151a175d73a117508213b7e6d3be0eac0f6c349b5af0d77f22a" + "5bdc22cdab221cb8e474011122e67d195a00ce9dd821242df8eebde04770527d559370e93b7f8c7e882db778b6255d487d2119acfd81bd" + "0363e27d27486d14df9407e8290916064230a638782b4a1b02582c1841703f88d0555357d9c0a2052d9d6bb7d7e5e1302c466eaa621e4b" + "4c6b42f0a1bf2588695018a295ebd7f031", + .hexData = + "5e9f606bffcfb96cd8905ccaf2aef45b6c78bb1ff81907c849fc10cbdafed6309df895697051e5c7ff473d65aaa0fcc79ee7c4b1e5f1cd" + "3f8b269230303a5d838e93b9a0f8cf12b8bf459faa0653c7a0f9ca94fad2e789bf89b8515dc9e9e3ff3c4fcf86c426f2557a7467005f28" + "ab978c3cc4a06faa102d8fa3ad9299d3891bcf50f926e3722075ff89cfc9061a3ea498e37e8202bcb4eedede8541c1425a4e278fa7a821" + "202ebb5e64c7052aae99fce16ae14371fa94614c87a62cd1576e0ddc93faf4af81d84cc65d003fc6eed7a9310005c05f5ce7284be77cce" + "dc287da88c9ae840ebbc6ef3abc440f089f93b06da4b7b4122c0b9a6f120ce0167aba1551082d93df8e6edacaf442b200c9ad4d5e6aa50" + "9245f955d7b3126e8b7edcd294cb8a8e9c52c660c2059d536b6c8c5f9364d86a45f501b0f944207bcd631f9a6b69e3b508946f539f7fa8" + "0c877b80522d08bb3f41a7a442894567aac96ecb929cb9c1fc5972172845b2859c094836a0b1755b3c8c50e54a51b93b4aa6958d646a", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_024_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000bd0d9010dd30b0ec8c396744527127508359e0f12aa4b8b09dc20f42040644d4b33f90" + "de38ce815367af5a8cabf18a71732d569bcda767767ae0b61f38108a021d197b2e097e60cad6ff186a3510667a4e19eca53abca79dbc57" + "8e0d30ba42146946c1f5fcd6204e17252be83121554ca68637e85e5534d1f2c943831d9a65de22c70812872ec219cd2ede8c8c3e78a5d5" + "250b3edf4bb4bfd9a9232f2dd2902b61eca43038d354a365dcacc623de3b062207f7807c9d877a603e2c70ae129c5d418fe52f023025d2" + "68b0627c0dbf1488fa078fb187b57c17c86a43116f94622c5ba31c4ca771428fb73c8b9ee7ff21962dad6b2094c83823f413bd8ec23648" + "186c34a2ba9f0d972af78d7882bedd926faffc6944c4d4211888fa4a49ced7f558d30929041d93a8c5d2275e0330909cb201a618f5a747" + "edc459189b7d30426c49a0d10646a10f015f1e418370874ec2ab0304515178c9fb4425b7c4747e6fef0981b8d599cd3c1152ed804a79b8" + "9737a5344848a4b36ccc9a29b7fd58ec854a5457fb9b24f192959050ea793b8f17d27cb8cd809b9b87957889947576137868bb30bd4810" + "c421b6e937fbb554f9345e266cab23623970f94df74a0a6321487fa655933f45a1fdff7252aad1230e518503ca22ff815d6427acdb57df" + "b7480bd4fda526470c7a3187ea980db8b75b486d77844e030821b804f32b56b75994b96a11000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000116" + "9c2ea4b5af83196753de33dfa044d16e442b90ec46b307fc761f19081e2fd13876dbbe9810aa8aed159dc0c137ac15116f54b2619029e1" + "93a49863777312ee59c89860d325d831aa30ec1c97a814798029bd91ad4aaec940a3400bf7cdeee53e0a065c8316a0da760e2e08210819" + "898748fa1ac25d7269c19dac835be10159e5d2e3f64350a64a2badf553ddda02d7e27c01b24d4662a1a748813abd423797d8a852a2a9c9" + "2c90363884395644d7ce4df7a1f42df33126c3a7ebecb604e7ca8772cc38290cd5192b081d5f34cdab890e4e25335845ae47b1e2738efc" + "4744ce854f26ad4c4151729ab995013641df2474e60eafe0db694b737f80e637f801fb25223a924e96341ecd43fde54a977bd668c5a9a3" + "95dfe66562891c211e888e68ec740f05e5cbf3776774689b83453463a226d4dfa263dafee68378af41c5391bea2588f356799578bc5b67" + "e6382f5739a428589429c9fa66bc8a418ed6a353a09f92efecc9029f51eedf9f98134310cc11ec064fb6e5c9266b0aa88d42e8e574f3fd" + "2f3da8e34a310324b42bec03945c67b54915f82eab1936972a2ae42ac1d71f3c552b39a3a62e25b7b38dcab1c4b71b89445dc563a158b8" + "614a5d4c4792e3e9c1e4aad4a854930f63a476441d90422e1a671b0fbbeda2015b189756e421c8e7a6253e354c7e116ed50cb410bdedf5" + "5689eeac4e8eb71c16fc15829b821b21", + .hexData = + "8687202d898e1a5cef2f34dc0ab0c57f1ac8e9c0b4e1c2b76362a8bfc427dc2cddee16722b748a521bae5a5013f94bbc2587654ab42fa2" + "3d8026c91dfeac05e5adecdc230943a5f4c711cf745f81a852c63823fdbbccf10f5455cec93575d4164a21e07fa9102fb63843aa95f6bc" + "0cc299f4a8e9e2b32163485e893aff386c5d573054c63bd56842111b61323335501f858b5e71a566931f7c6f5ea3db1beb29bbdf095eba" + "b66477b666e7c74fbc3759319fd25f7f584d6bd556cf067313918e8cdfd8b96857b8c1e50ed1a7159e13ef7296352bea25c802ca0a8d22" + "9b96fa66a6c497b7ee5dcb3baf69152050e9c3873e2891c13dea277bfdf5af46f91c406472e96a5e5ffe2f326777c59b9b5926b2db0961" + "cd6764cd3bfc7b09af75ce79a34247bf860a502fde341f6e736adb6579fde5b56f8adae621580a6872ad1493ed21f57dd8b2547e0f52f4" + "ab21950c8e77a9d15caa5799cf517581f072632acff9309dfd3467ee6e9f3e72b0e9e7cde6dc96d979a8be167337d4689da8d84b46ce53" + "14b90ecdb15c84af1b57b906d53bb9d751928a02cae04dc07e752d422c8b91fb9ae26e3c3f034cc488a98719f70146a62fd4999a4716cb" + "52ca1212fe0c5fe504fbebe7457253f7993eb5955c440d1d918f873126e6d2c07a613b56137ec4086e9f8dbff10b2333be22203b2e8e48" + "de68a475b9453c38ee89a4ccfd895ae851", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_025_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "50389b5555550000000000000000000050e79855555500000000000010000000000000000000000000000000200" + "0000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_026_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000abb40b8b0a75bde0d4b54aac6d680c7017c5988f76796cfd1bab57d3742fae7a0df13a" + "c51b64ebee13da5bf8a59dd5890671f2078778a6e8e2f78683ebd9a36be36270d5bd2e94d9fd16c7eef047dabe81addde56a8c07c057b1" + "87c5f727432900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000148d0ed08452253a9" + "126be3c4260db7209e6434e3ba599a67e8a10c78e750054d4bb65eb7127c05360d035077ad3cb73e5805aebfd28f2189acfa371768cd18" + "c301fc00f0981e1c14d377736068e93e8367c4f7bb0fa5a1aa3e827b2bfc52d595", + .hexData = + "5f9be2e65ccb8b571ccdf77b0735d47acd7f0525d465039ad0876ddaf68045d04e84250a35dc3a4facfd7560306cd00894fea152a70124" + "6f08df381814ee1552ea9b0735846e9c458653b780d6cda5a042d3eb9ec532faafd3bb47d718b23c10", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_027_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000abd5067aca33441d55adb08616728eb4fc6fd2a2305b65d844e649524e33f85f7f8443" + "62305460648dd18113b4ef745d8f84a1317b7f0bf2fcedf3a98a163663c37cf3d1735c5949cbaa8109e1f414633979e5921b54e92d9aba" + "955d4611939be832605d80c21e7d1df9d74b231117255c34457a94219248a3ffb26e5f56c1190000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "015223a2d54f92f21c93b85389c5713d8686a56daada32d69c6b5329f98e2889b21ce2bcd35307028d0ebdf755d44822f81682f00b175d" + "c3f883afbbaa6fb7ee8738ee428b4ca66b9429a0344404b2b7ee2dfe5e8b5e02911b588e1da4f1c966eb061d6cb7fb94553d5119aed7ad" + "256eacf50f7179fb619add182443ffc322a601", + .hexData = "9e70d407bae1443ed93a186b966ee760505748026759887955bee36be9960a244e210d7a29d7b7e014dc248d3d5" + "5170bdcb89721ce71172db79ccf0f13dc7bb273e913fe92a314aa5b591fdabbf19f45fcc307b88ca3bab20e1a83" + "c80bd249d414c6e2c4cda407e52233ff13b527dcd127713e48d9006e62b2bc885a59586347", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_028_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c4f60d18cea8dd8e0635c77ced7180a2e876d85668a2f93eefc831bf5a7df549303737" + "7c78ef3abb295a0a3c61c1ee95200c5422ff0e320596e5911f40951b587308182a1564c852a0dc8e4949e01a7a63459f1eac07d46c9728" + "e865c68fb8cc8c94d087066e84169089f1bd1ca9279729dc2330182ee482eaeb9fbc4cc131e9da0ab86c161e7a019ea08b6b2899f8f76f" + "8dcd27e65f7c92ccb0947d6834ed05242b08bd4faca3910119271bc3de7775c53acb92aad7c3d323372c4d149d140ac1f66172d6a932ee" + "80bf123a4558c64a7ad25b912ac233aa599eda965e271ac065c68909634e18efeaa951c35b2424298633c3fe8783deba92e22be1dc662a" + "e5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001454527fc068a9b491ce40321ebbc547a76f9" + "7d427e907aca68b866ce9ebbd7ed829898da1d0a3e049f197caa19d383de4ca4295f1986db8eddb02566f166bf744f1894af10511ea6f8" + "ce38f88b93d69c1e97d8cb87c345315fc4525fa102e102879abaf012120240915b027af93e809f0868d4b3507e057e09b30ebdc1dcdc79" + "7d30d27f750c35e1ef66d1aae17a283aa29d7f0552d49fc8b2792cb4c3f8bb8fc437d334231213c2b0d671e63502a2c3b95cbd1b424c39" + "1c17ac851268117c736d2dd28898c69c0c8467a5588b2c6e1d8bd21bcaacc524da0fafcee2d869aa0047a51c2c7624d4b9400c2b2109c0" + "5b2b7d1a9141887cae78911e04a35adfd341", + .hexData = + "0ee884e4926c704ee96a07d8727fbcd4452bb17d65533a735665493befca50dcee93f2c5a331042f30254e78de7f2d6067f8513d56f157" + "9b1945f2a3e312c59dcdbc1393765a02a6ff6ee9086e186a97684909a15512c92c22465ce9671b534975b8aa1904a2f06e23e29d8a438e" + "9b15bbbb9ea6182479e7823c0ebb27394b9fbe4c167b8ab82f9637c9a28d6f09cf5c8029460ae649407a893b1e68b18940ee77cd8a3439" + "6b7d8fff53ce1674e3d58f9c66af1ac858d0cd520b578e0b3a855a7f76755a2c9a2bc205b6541b9ef8ac546aeebd881ccf134c29316053" + "7b0aa8f17a02a8fd6681bbfc62edc56991c9042d3bfc66844182a8e36a9edd35ad149668", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_029_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000ee5f706a43d3f09582c6f0a7677e2f7695ffd50df34c0bdefe9710d3be0b08b6225f90" + "f4b27bf4163cbfd0e088a85cbbab9d99ca499a7e33e46b7c8dbd49dc5c017c18409887ae7c67529ba4b76b534cfdf7a6b9f7dff7411e35" + "958879e8c912229ac0a30d989aef962b97e8fe2c5029db5f51ab7deb6e4341063853d3318bc21f799d77b37302e976e2207f0672cb828a" + "8b609a996dd519d54bf7dd051286b9e0b0447e789de7d724ebbdb61c5dd38b677af6470bf5dbff39ee5f7a6f811772ab9d38f1c42e371a" + "6698948e505e3b096917c658aa5d0a48290f98cfd7219c324a6bcfcc66e244ed48013b52eb5a7bef7786f80089cb4b2f5ff1a8365464ad" + "85f50e962c08d1cba6c7b2ba0dcb6af91cff35d5d834c224ee0adb6c4656ec575cdbce4fd60bc6d6d05597d70c92a2673e24f94f515e8d" + "c8137e5efda4d5f8e51b42d6ce8186472bc92915da9995809b21d2f371c8d0840802af0afd43cd76cc914eb3a958f7c6bf05ba4705e2cc" + "c8f85de9da4f5439da35a639fa326273f228a9000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000001000107e57b78d9b45ca4e74725d3b5d6f5458d64832f4a1efbc9b04f5acc58e04eb291e2ee8f5c" + "964498b3fc7ab3e57306576530fc563a27f7044b0dd07b7588cbd6f469a2f808d57dcf3b30fe5cef828ba8e244e0ee0a2b0e2ac710695a" + "b307261a06b16fae37161613d7baabf698ece8deea1877412213b97c5adc14e399fc6b2fcc11204945d58a84275f084a8cf12292b97a32" + "820c9119dd1836c3083c51c7cac289b44b283dbadf62a6b88b1ed770d98e5d01698b18e2e7ca887dfb3554666d62a954f1e99fd0006b1e" + "8b67eaecbdb0d3f918a880f0ce5cacc614dc81cc2029ead91ebec3afff48e704827e41316a55874950d0801f04b55177cec74c32f8fb87" + "c4102d8a5a8a7440416d1664587ec80538c80c22ea0223163f44c9f3ddf3b504620246e26d58b17bca0714ebbf98d916cea6d88dcea325" + "aaa7a22d184151b4285acee2ed6c064dfe0734e796298a8a5acb8a84462487be3b4629306f08fa2e507427d9bdf2a01b106fa832804861" + "012515bbb4503485c38a5895dd5c41575d", + .hexData = + "0a8424bd6c97912903cd8f5acd83c99474ca3bc9d793393394bcb5b1e651a9b576e77dd3cbe3914181d2052fa20fc118c25e24188f9e33" + "85d322a33eae700ca4bcac74f9bf0acbc230c54bb8961cfa76f46b4250b661596995335e627d458aea2491ebccd99312c4ae5b05f2f28e" + "020dc80d96120a901cc1b35a8bd00a0a539c63c673b5bc73567e0fbe791ade0285eca2b6d6c1ca9fbb1a7a25e986061941294740197563" + "7f30d813d19c554f46c823318ac8d1c7b2db8a3225950b265ec072e42c46f1cdb58a2bb537ab31b3935e772a5ab06535570f328b2c6cc2" + "b967a0cb3f37629e6c6e072493b5ca6b6694eb992a9146c469e3b1d24f82cc13ae0465a0a03c8506872b08994b51a30e9d48e2ddc0fcb8" + "b5f525be9622edeba13fbc922276710e4809cf83e9a46c4889b2d01b23bf164db06b8e84b52ac7d50614a053837d071e711c0792867ea5" + "12208bf9626c41ed53a25090c817dd6c329c9a029e836689b13d9c8a694dd51e4db4311b5f68b56c2b1feebea8ba39e9073b371ad4b9", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_030_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000bd242191c7b58734f519b77d69978689267e81ceae91c334890fb7e8391b9971947dc1" + "a1919cf3e60cc783ef51c3702fa2592f4e0060a5a03f2d3737ce9f2f6813b6fa2244835c739d3b8065c52a0aef6924f648a4a7d65e49dc" + "4d95c7265a48ea4ecc231af6b5a78acd94eb29d1a59c0c474510c8c74c087e89dbece00273baf31d2c915357e301d72ba33521537c3a19" + "fef215b1416ed04cafe06c85c78abcc60553a6444f0bdef3bb58864d52a23d8447da98655632f8249d4602b1cb99f467c99d6429bba5d6" + "cea31db9548178312db72d8cce5f8559b76b77efec3e19eba97eb984ac9232b9a84087335bdcbe2bd50d04e70ca0b99e0091b8a3b2818f" + "905b9e894858db311cae379946941adb85b03ec13d53b5527ccbac90bf8052bb0ff33becdc1f2f493e4020ebbf1778dfae67942f8c08a5" + "c069647de3532eecc3837d3b635c7ed8eadbb60adbfe52792b4de89ddf410a98dc59964dab256e20bc6558cdb7f7b7ae559057dd0f116b" + "9250af84124a6d9d72ec69b2c756a1e711b6aa62a5a01140aca5e57aee6f738eb3093940cae3106711596b080619d34390c776804551e3" + "315812b23a9e309f5f2a6a204516a4585721333b7db48ce6545325030a14f729c2a095bd98cccd21de27f84126c2e60ce261fa64879ef4" + "dee4e40883d67b5f6389b3ae1e8c9018c96c2a62b5844bb6f556aa433d77a4fbe3d0261da1000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000184" + "77e5bb0030373df3dbcb135efced10e990f8c114aaaa190555a8ec4ff2f0890802fbb679118010c32a8950f7e6f58fa718e774adf70289" + "353629d24038652f737f57b8e05b5048f8fa4f76f79bf684af13601a8897b41fdd831a23a89347f0818a2696ffaf8292913862f0411dbf" + "eb86fdf37549e9ab6ad7951e1eccd56ad0a8acea25ee45438c6a72f99fa073a431dd3b1db9eba774411734a6eddad4626acc15b6fc6023" + "2ca13dfb1c891366a892852efdfe761ae51fbe25187f929e927906a7c24000aa97ffd6418ff3d927c4524d3e59fca01d6e7be366b55da8" + "0be68392f65a607dacf731e891291fe35abb265fd4fa7607f6198a7bc39399b2cfe30775240fae0f0db1239e8b072a580f4d5ed2a9194e" + "31c11bca7c6903e36e2224a9a9b1926dd500f1aa6cdbd2030ace1fcdcee9aedaefc477ad5bdaf88787d53cc83d2f00f25aa0f57afca753" + "de2368c7f70245bd92ccef7a30b9f799a328f658d7a285265a3f03d10eeb7d4a4d42ee202ee2f54d182fe88d46608949f337b1b7a2691b" + "0db4e8457ec437f921431cb40adc52163957bb2da94a4b7d6f80c38ba5d0febe3504826f279795ba72d358882d932e9bb85f5bee0d46b5" + "e8e91bf2940ddd8ae7ef274f562eb4d47e380eae720f05293830313bfba820ffd71581a95cf50e4429ef9a020d43a09fa9a55fe1b2f6f2" + "936d4168586db9160b14f3c8844d81f1", + .hexData = + "042295390fbf8589571e1adc47b7ed8fcae6118ae762581b2890cfa83fec4662488037a690501b84e037e51ca9e4d9f1cad8e9f937d014" + "729bf9ec630c357f94dfafdf5dc3c335f93483b8df99d13f88461620269c9aeb6ca68275e47a374d60d6c22d632aa286de179dc1ac90d5" + "b5ba87539f292a083244d8bc66e68d17469c9b88c9e26f66f68d39ed56567ebfe865866120d905826852561e1af79e12dd4831ea843841" + "bf18eaa62d3fb5ac9fab8f8d3e271035dbdc3086bce5a201f4ecf32d0cf8279826cf1d4167c1cf066aff055ca0ca197f9319c065c22029" + "968c76d16bfaf6634ee28bbfbb053dbe558e4c41c4fb1682dcb1d2449c1c86ad9cfbd9f6635103064ca1501133e4cd05f13248f108bfe9" + "0393d31369f12bcc4f98f285e6cb9481cededabb1619d6b92ad74bfa824af9290e6ab98a29e7aaa992aaa193b7474b05b526778140d99d" + "150c154ca7caa6c9be0a8d362d8c7ebbfab5ec707f8eb7d52b86a3d8ebc7e7909533a19ab83b6b0cd432eae2400f23761b2379bea8055e" + "a456b636839dee074b079032a70a65ebe89696502a6796160fa51dbce095d50d5f4a7159d64c3e1f84eac2e22b7ff8a1873a075d1f7fb7" + "adecce73a5b226316be1fd24586a08467a1fdfa9a2b47f25f5764d1263b5b121be4e1fe383d9c9491319883f9b618eb7a2359482118eb8" + "848d6b6a53a3e851a1c70832cb1123e99f", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_031_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "0000000000000000000000000000000050e79855555500000000000010000000000000000000000000000000200" + "0000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_032_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = + "005e9b55555500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_033_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000da938b9dd72dd0646cf4a110789f7576da281c5bc54848edd5305d769798f1d50a9fd5" + "9e0881824a564eccc9748932a52ad80832c1a5b3048fedcf2767cb7331e21a9e69472bde86d26f0955a4c80b4d0e64bab47404869656bf" + "1d244f2f30daa7b1b80e8a17fa1527f54562a658a313f63b91a77e00504a001b0e2129db181d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "0120293392def57bc33b10e79e0fd18eac153f6fa4c52b74a7a205c2cacf558ec7c50f6d941a364c207a00903b582d53c95fbb77c15822" + "f46b486e3a5bd6f6e594fcc0036be7b34bf6ef1897f8bdc9f5352dd9e47c83ca4a8e8670390cffee57bea3c3529f382d76ea7b8b91889f" + "87eeabfe6c35dfb10257df39c31d3467dbd7a1", + .hexData = "72102aa4fd30d438cfe0fcb04d4d5b491efa17b4f75f636648169fc5730b29bbeb781ceef25ad7cceca3e653a84" + "31fafb19713ddb566d7618d881aa693248d7bf2d8ff6c1cc7ea2aa1f242227507ec248b412fcbe75aba812578dc" + "7e8871f8ef19784c21970236be43656feec81bae8577aff26937cdcf924dc8624f7e6a03fe", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_034_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000b7e7b8fe8778adaac50fd7935451726c84b0f60dacbb9462140d50a39d065fce6bacaa" + "d29bd9d6972e732304c30ee967676d8062c56e5ba6328e651a7afba7f0992806d08f575389683f412a63049c49200f42f9410651a946a5" + "130f3cb10e6d8e04520af779b4d6d192578540efb66687a896cb3d0839692f4f1853697e9f8def35a94f6fb206b6375ad9e6c5e8c27eca" + "4c25de185ded5793d0be50f882a124c4cf9774621872725e6365e6525a2d61d8558ed385c6a15b8b94b5548c42313c51229a3c3e5161a5" + "d0c573808a30ec94f5ed907d250070b069a9ddf2ad666018a9f549dabdf8f333c6414c9acd3a3565770eaed7843cb775d22f7d790b97b8" + "13000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100018d1063a86985b9c0c9d3b30a419d0fe6098a" + "2bd2a57265092e54604c800009b12e8a8da56b029745f3cd41493fcdca5f14c8bbb807b4f4fbf0bfa4f1c0f0140bcb8f165b17f8660d7a" + "373ae72678bce0a284d25c9af21be57a58d8dbd13406db261a4e4c3733d5f10963f55a334b2c604d229638632251d74b00a2aa28bb85ea" + "6e6fa3e9d4fb4e8b2a9f4aed3c2e84e488197383c457acb426babf2821b40a7a2b8c9a624964e8b223f20428e9d02ad13ecdc426858c17" + "2070924068d97856b56ffaf5d47e643bcbc39d85fa425d93c99905301ff10fc15ec2c2bf49228b69cbb50895ecef1140cb05bbf314157e" + "c8c21796b1eebea225357a4a8b89385eb141", + .hexData = + "1c0731b85707b5a67dec0bdc291b8a7c00a6fa2f494e573b47a8c8445eee2b49aa6c6b015b0d4f8be60074a8ee01e914a8c7964d05596d" + "776c5cdcb826db4574bf579c7d0c204fdeb61f6525f2927adddc0434d48c560206c5a4e95260531aaedfd3ad05a6afa2423aca600ce084" + "4be4c0dd5c89ee5b5e58dceb92817751880108bdea99acca257893ca0c407fff41f2b3eb8a4c54b06df07d04aa26ba8e349062e0b6f022" + "6e788c2c57a89a00bf1b5411ea3195d0118385a6bae7efcc2257648c4c5a001c6bb7405439adda7f9c449b6802b6fa9166c448d50b7383" + "b4b0fc0d0f043a1ec42599e31591be49a344cfed1a0cea16d99f45bbf296fc7a11f2c380", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_035_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000ae9c2597d382b1cf800c1066c2f0fddd8e6e0d3d7f60b33066291cf20ea84f9d54803f" + "e6829e80799989c4b95f92424237909b5a1cfe9f99890a98e4a80548523276c4cd421dc8220c673d21255c29daa8862551ab5c6c19684c" + "8ab11ed43bae6da8184a0a97791f7b3d7b5cd33f7cbd6b2b4847f6a8bc3764faa7593763f5a3fc253e616e73fe26eb08aa3060d40be98e" + "f95c39ba7d8ef3528760b8c5c9c8b7a7f74f87498e3c33a76d4c94863fa9a3d7aa88019eee6a35ccc43d7dad5f8a0fef2cdba741f900cd" + "53e8155c4a90f4f79c7892d445e7da3d6a2496a4ca32ec8fa325bad6ab0bfc4911bce78be03ed0043f7c5fee60d4b10c7412301c6dfd36" + "8093b9ab12dfc61d403b7905ec78327b384c94f31059021b6cdefcf8440e1ca74ba5eb98d27c158825a8b7a648c8d0a23c28d15eec8924" + "058ea9d08fcdbc99f2bbe017228012861df4fdadfc20f58600b2240c7a0048ebb2ea2d8f846a97057c6fdc5b1cf916095fd51659063400" + "9bd94a988ffcd2007ddd46aad6918bbd3bcbd9000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100014cbc00655da56500fc93d0ad6864421c98d8526741503ccf3b463c1b4047c55d2de282b289" + "9aa0794ff95483e6b53efb1cb227238df4742d24258d1587a572a7f4d76f1b893fcf50ef447b7fd28c53346db52e375ae86df52879e2c5" + "7df7e5167dc84e8c536547ec86db79184d19ec76cddf228fc59d57c1bc55cf2f8d0117d56e1cebf22379442ad445658d873008e0265dfd" + "a2bd0b2ac451f37e95150edd6fa09835d20d883d7ab1cc7dc813cb6c80bd698b05b353b1475d6aac5f4bceddbbf3040f17f701e60a945c" + "cc12e90354b6c508084570a3058dde4e0253e961c014547a2ce41c5b9ba04704329595cfc1b451736658cd3e6734e30864f1a083801c14" + "fd309c4e116329c5f0d6c12012126267dff44a47d4d6fd2f6e8a4c0c50e14bcd3cd856ba26894451513e139baadf3a2f992f22532afb8c" + "c7607413b7d42230c8c06299b46117706658653f838d32a8de41d8ed7ea779ed1a94029cfbb3f4527bceb5ceb700fa20bb5e5f463e17c3" + "10ce7fe7cef8179d5cf7924697551d7301", + .hexData = + "1a4a913074a6942fae678aa174fba8e958ed838d9720db2a434c1ab80e97ad60cfd0ff14c46c9d76a5d3389d5952a82ae40c25aede5b2c" + "23cac516b0927dc8740ce199be8f67e034493c4be5a7b5781444f0bef04af35c8de8f11a833645969b460ee730154df3e86f2f92e98295" + "b10ae10e6cd2544bc02081f987951af012bdf9ed2ad49869891e178b2fffdf10b6babbbebe92f48c342fd0306491e5aa52783f525e6e81" + "5b598042444cb703e775e4c79faf89a27ee2cfd319db3af4ff30dee3225830a304e35252e9c9b170be90b98d3f5f2bef85ccc9b4892005" + "e3bfb8ddf42c3dd4f4d53fd87ff2a8e6a8442328389962680960dbf12d85c92bbdb65a10b4cd51e3195bfbc5ce0bcf0073818ff18eabbe" + "29c441ae15a0fce82d1fd7370bbc9209e15ae994311da9399701fc67e2c19b0875898deb21aa446c87f7c91b611dc95e84a7cfe5c900b3" + "6c086a173d79cb36981a814bd8a0ca770323371f085935f04417cbad6484e58332e107c5fc9bd21b8c7d12e855849c7cf2be7fac5f3f", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_036_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000a92637cd544520cdb67f0aee8c620047937df05133af415e2644873f2a04a8b5d1ed19" + "667e0aa5b0a859c0f881f872067e208c98ce775de153ce95593659e3e4133229749293f83af9d5b6d15b35f0582a3b20bb7d243c5b161f" + "a1326ad5402b1bd1f0e7da929ed5601e5abbadee4243ed6bd364aee814788a6204efc2e6a4b1172f79215c02c49ab1c3e2f9c9cd03e35e" + "27acb023fd724095b0b68ef069a746067516093168f84d6040c64d448680bd01f5af31e78a57b0f6e36d4274f54244d5df0304c3fc9d32" + "083771cf322dd31a4e02b9a55caf68bc919848cc126802e5883e015f6dc48f9de821b1c83142b674a374fd7d0cb37483824ea9efe0151d" + "eab15e6ea8f54262b80b6036f6151c82ee6804d003269163ab52bc62ef6b8e1649975bfae50bb8b22cf4f1cd518c9e11aecca3905bb1d4" + "866fab531ba1531748e8722a7d12d3ee52014ad6919f10feccaa1bc3386b951bfb8587c7694cadb9d3be984a706d40505bf7dfe1963efb" + "52fd1ac8e612a42ed934b7e0f132b9118ae13361f914b27a5ff1a7b0f0c27788d737410247c2e25124c982926972b87f35e1e2a4529235" + "04474dd8981ad18b0424ff40754a271652bfb35acffcd25c46afd5a69ab1365e7259b05f04b12bebc7ec1361e909359deec133c7c4b58f" + "bfb2b8fefa21df15955e31b688bcdfb1e857d955af09e5b724b9a11dbb3cc7f1418f09995d000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000104" + "63e68ce0c40e8ee84eb1d4f135d5f605a0fe2ccd5f9e1db8768ce019d21722e8f8f370d292aa2c44a257bcdb7abc52e8d125750dded143" + "f8ede2b8770dac398e39fe13757e7bb1e42c24db9837752e84a2163e67881a3ceefd112d02d2d820864f53a660e8ef5070773939a7d108" + "4d450b48685395d87a2c7550d57c448a3fc26f4c008ea7cfbc8822a27083495bf179cf23cf4a8fd8784eaa5082b340bac3b9852e763c9f" + "11dac845c61fd948786cef711604009379a5313343f1b6a16affe8612a6de43c5944242c743ac17da8fe04ca5351346fa51347e020fb92" + "faba208501befd6016faf749401ea2288d27b92d48eb0f64d5ff8f2e41a66d806e6be151b4f2c409e0b8035ea2d63e9baf538a122e5e5b" + "02c41f11c218cb4e86665c11efd861a325a03fce577de17928da5a2fdb0786de366758c7d89514c3136da75a7095565e9bfdbe3932606d" + "dc43d631025828cb95703d1a7907c181126af324f5801531535bac8a6714204e46ea683d287c4c52f92f0f73715a5b8311d136aedb9a69" + "608e18be69e85a8c12b486bcf72f9a3c1f1dc01b5c77defa6b66999eabc14337d39183fa82bbd9de7f12ece728cc3b523e342c21363e52" + "4c8ba57b32835e06b8695022991d123afcaa7c6bee5802616b8ba5507e1276c0f472feedb3fd0a5c3f4bd2adc986c78d079d210537be05" + "a47eca98a7546b10c94e5f12a81b0921", + .hexData = + "3f8f6c4d7a4a5f2a52d652198476cb4b7936378c0815fbcc5e646b3c60e3495fa4d0ff4bec76b008d7460df745b21656d34bc3bcb45a7f" + "ae2a5bfe1b227f88d9bc78381e3f2ade35372ecfa34e4195127572ab77096899c0d74eb0c444424884183f1725fd5068c600706b94b3e5" + "af61fd705e3cd5cbdc6b60496f34f3035939a9942c6bf724a6b68183078e8e9c66c216bf89df0c4c27f92c4719e7760db16d6e0b41f1df" + "b1897ddb1348d5f70e29649f2a060f2ba93b2f01f6374ca1c53648d12d8c74b063e3abcdaf5f5a4cc329a04c7a2ba5e694dfa5287e7ab4" + "2565dc533e9f4e7feec7d81519e7743f46e6a6093e1d58a3726024375df22644591bb2f40d4c4fb56832f0e697094a8727c151cba311a7" + "012e003703a4c0f8197b385fbeafa06adde6aeaedd1a4be6079dd29ccdababf5b166db8d501f673d9d7cf4bcee53bfc1c89e9dc9faf490" + "ee0a2d409d5a4cc9b164d847fae31977cf6ca597d4bfafadbd8f944aac5620e9e2225327aace2231fc66d4fb45a66dd4e9c156c1aef053" + "7d53243abe91f7a4993759f86ec692e962ba64d4efd3bbd928d4c921d44f54761e12a506a4a020ff7efb8ea629bc904aebadecd0cd6351" + "b0ef04b9650737b40e3be064aba627b1d175bf16448e50af4710e7413efe1c45b6e087af7a6e00bcc2e37411a17b9c2323e04da7d42f3f" + "f24807a3f8f488216af206cf5e109b27dd", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_037_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "0000000000000000000000000000000050e79855555500000000000010000000000000000000000000000000200" + "0000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_038_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = + "a03c3df7ff7f0000a03c3df7ff7f0000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_039_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000d10cdba0a029d15254e1b98a1ab3fe28387017976d817ed229a88e521037451768a681" + "bd6b8944d1efc6be41913da3dc8cf42cae0d0b449e2cec4df0537b1702cd9a79b8394175c0474e96fdc7d26616c268059c4d01bb6ffa70" + "c12fa591e40093d988fe0c1d76df2d5999827cb12e7b287d537d477a7a8dae6ce9e6a1c2577d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "010b443221f9ffc6f434f6e554f81373431fa78addf25ce444d751ea39a9fe108f2e68aadd568a53572d20fce7f3b7eab8dc2fdca894b3" + "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" + "5b83ef84097f2112e64d11193da5dfcfbf9a51", + .hexData = "c0789b555555000000000000000000001efa17b4f75f636648169fc5730b29bbeb781ceef25ad7cceca3e653a84" + "31fafb19713ddb566d7618d881aa693248d7bf2d8ff6c1cc7ea2aa1f242227507ec248b412fcbe75aba812578dc" + "7e8871f8ef19784c21970236be43656feec81bae8577aff26937cdcf924dc8624f7e6a03fe", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_040_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" + "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" + "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" + "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" + "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" + "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" + "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" + "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" + "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" + "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" + "adf95c1f761b56c8ddf2e78e532861cef681", + .hexData = + "0a2b55577fab07262b26f974237ef1b3b55d4d8f6f26672144f12958738d2ef52fa64460ac9d48fddad78f778faf650f10c25185a30b3a" + "6b0b112a8107b99f54189ec1d3297c76f4677197f536f9917813c735380a0a1d7ef3f1839a2a88e3adb8e9a56e7842573b80b76afb3e32" + "a360d42efbce9fe874e4ae1e012fee87f5db1820e78e1d428b452a0103825355389980dc6d40289caa8c90bb9c7f4e69fd8154230717e6" + "0c1a1cdc1c52725ed8329d641a5f3dcd5f4774020082eba94137f4cef5a5f8917a221b53e3311ea3b21059d6d680d8ebb2dd21ceb32e40" + "bb384da3f37d29b44d95ef6cd8c2de66658326b73eea8785010ef4e8513ae575376f2795", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_041_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c000080010000800100008001000098d7dc7ba96338aa0f01393fe4c848f9491c9e6851e8869eac27736dfffc30347c7723" + "457f79082f61a2188ebbcd1906137e7369f5e6fa5220062938465456a46367e9551c1dea7f616343f2bd6078a89b24d10b7bc08fda6d95" + "fb9414bdc869e3449abf06b314149bd5a6f0dbbb195476ca4ee29ec65405a0b8f1225b890d6e7ee2cc39c1551f7a1fa42981bb98cf5939" + "83c5985bbb13eb545d57c46e9d60a05b50d0bc3518606ba5735c00607068556bcfd788926f0660fbe386777befc53dbec3a26c61405dc5" + "92da9c8aea3b87299e0c186eeaeabfce7c4f0a67fe952411fe62cf6007a1c28eb7e91316d72e054857136b8b75b74eefae1278adeb5c60" + "ef79f5ff9197d67cc0ca8564bb6110bf5e1e2fa915b05fd9d6bfc74b1fed176167638c3af06f5b016b5aa368297952830870de51040160" + "33535b0948b6b8c548db76cd13dfc20742e194ffbcea4c491f884e4d598987b0ef86a11b771b8e244a9677ee29ac104588f45f90c9b0b8" + "2145ee35c324e6ef9007fa424743d00e3cdc39000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100014ab39e1876967f1866d303471e2b61b72d2ba6a477fbfce7ca5e51c55e8ac488b2988c0da8" + "9ae00c405cb841f2b9f0540eed0bbdab28e409858b5d541ad397b12ac09bc33445ced9c9207a1246cac2ce2d5d962a55a6ace8660d1af3" + "aa1b83bb750f8fce7398cce4b1b17fb152c3a442aaf8800bb4ec5c1e900a3418c5c23b6558f0c23e2c26cd86a3b6596f05e04edf5e03f0" + "6c61d112903f208c07fec43e78c188c32c698aeb7d51550b8f479348fb0f017b674da2a3ec7cd01c65839691c0b58139e1b3d827c3961a" + "26d9d64fc676955e4b09ab58d4cbcdd15d34cb6da228a9b709dc87cb6a0f6826303e082aa16c27837fd62b42682313e3e9dcff90b06aa5" + "318704f4260c03c41ef580a70a2fe4cad7ea2a4f4793173e0c49d7995a04bb97d8bf77fb14b0efb9c61ae334612587d76c92f7ddd2ed78" + "a86830cfb4715a02908a6bc917d8b262349d19427c58b0d26be9dd105e819a422b738bd86a0f69f41d668fb6d33de4fb784af5e42d3168" + "ff5fba845faf39d5e65cc388bafb6af671", + .hexData = + "84807a24502876d729e545f2c07a4eb7df7e15782d3d3a5ec29bce1dc2bacbf03dff90b39442a3b5a3228864ba80af4d27524cdfaa40f6" + "9f4f34671566a6c8f127ce39c66e7a35425db127f56f8ea79647e7a6edbc2ff6067f93efdc7077fa1dd16354a3f26c3effab326be32dfa" + "69f48ec15f9d7b58ad026ff7f8606d91b69474d740170bb48a32c4e6131181eb34872f6e0343ab91b2d182e59e614a078cb772020a170e" + "5e1c925dc84cde890376a632faf61da99033a9040e253d9f69c353e286e7d071e46c1c04633e651d147e57907e20269202d4a6b2855be5" + "0301578410419f9e40bca573d8b66bf0313dabc375a8b06f878b84a8e9571c86fd8f80b833f8910351ff2d06052ebf50c8d314d84dcdc5" + "3d576a61219ae99b00af82890349632e5d60055a2d68b9887759c1173c9683f2fbe2b88a57c709994e18dd7813aa2f35a4587b753737e0" + "3e94e17865dd8a6daf89c34cb1e9d512af5331daf1fe072e8ba5f66db6006ec406c7df4d70142c706c30124a4c5d084522f404e74438", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_042_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000b84a40ff88dc4d56d93df76a10bbcc0e6ea27a3256cfbbb2b6f87bb9735752e7a51893" + "5d1e8d40777736854204be4a273e76378653178e5201a82ea19e46b59634a424fc6968eaecb76dbe53164a8ef6b822193ec6dd6a7d98c9" + "ea5dd3aae031c854347c5a883b18baf6541b330ed09947adc4ce8974c9534bf572d4b73160491add3d312afbd2a249685c00b995262349" + "dd6ea374b91403be3b008338b7e9fee6f14dff5bbb57b1414a1b912858bdda0cffb2dc0f1a543882ad0b08a95aabb7f4174ea9fa487e1d" + "ac6bd3a531d5ecacae1252e0b0e8ea40d0aa9c691db86df1dfc2c01afaf41ac7e624e6384d0d4bb603f8b19eccf80de9125b868ced158f" + "56712b3b5ffbb5d981e1eca28bc6ac81f1a04afc41032a8891fc5d3d25b86511f6d80137512b9d5e04521e3eacbd60c5047cd7c9d009ab" + "4fd4657b41f28a8f0cb51c73fd89a6eeff0c031c273750c147f12806766791c9cd4beefd71765ce74f5fdf0689ae2ef04fe34931078484" + "04ae44c01f5ddfdc2166ba9037862e132f01274800760879cb23fa4395ae0e9c5380d925d3fcde1782b754f197bdea13eebeed3846eb33" + "5145bd67baf2c10f6379c0321f2abab2e33661c153f4c08eb3eab0897372f43b4cd4dbd4d9dd9487705f4a7cdff310b3c7df5d7d144061" + "40b8a915f569bcdd83b87e8c7638d80d46421b41d8507e4e76ae6ad307fb90fe58cc62d0bf000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000121" + "a31bfe0842fdb2ce702b0aa70740159a47f9b9da728c35f083a6419135ed21eed66f7f5da6369017a851e65ceb46a9a712f8cb81bb18f5" + "0aec61a68a3729c9c2cdfb1a3f3b313607bcf632402d57aedca90ca692b1b3503d650d6c16c867a76e8340193a8507145a7bbf9a3f5582" + "e99755b648647a768cc79e8359241ed50e42e302da4898323800e21578e466bed14e1826ab9b107500c1e60f0fe4785d33737fb3d6da2d" + "75b21ad2a5f976bdcbd952ea11016d9846ab11def7d69ae2bbd915aa73673f11a0435647501824e281127bab48894e8114d0c3c5804b07" + "6bb455a39bee687e49b3e1acb62b77374927fa8efb03a09294ec25107eb82e5ccfc49b98a4c5492c45723b2054454726771e555c105994" + "5d3c1ee5b03bc514d44da961420f4c82b5e6fcdd8849b2395bc9fa1487c0a7381ce651806eb384e90445a8d9e08680d518673bbccc096c" + "9eb232fed9d5eecc7edb09e09ed63884c666c8b9ff65b11fcccae817b993830b4766713250c175fd6d5ed5d18a8c6555583c9665a9e701" + "f0a55725824478bf3a3ec794fa2992afa2cce454c2c9a861afd9cd83dbb66e55aff4e4d5728a2b22a319b39c4df3a3cdeb8d71062d0215" + "12608805239e96d25562445fc30b894890dedc92c8d456029a2d382077956a0f4335c95b06758f2e245725b37c95da5ac1ec3ff4a70ae0" + "3f069a7a11e27ad124aefabc32947761", + .hexData = + "afca445e73fede94488a5d9b000589a244bd2c27446d26f32e55de317b15b2ca2e8738dc0662db53a472f5a4ab7a8906a9e7bd001066f5" + "467cc235a0f335942e57def499c5b7f4a0dcbccfc2814cb2daa59410f035fd474447efee395665063ac2c44ac407ea8bffdd8bc7ac2515" + "dff7cda5ec6cb711038e54b2705fff90b2f64e9961d10b784c2ff71d4b5f1b558f406fa768ce11c0017abd24462cb206047dcb5c90876b" + "9dfac79cb2093509b9c82a21f9b984342ca80c8559629ef11c08efa543f7d63049c719d7a40770680ab426633f1d34e149124e7cb1cd8b" + "f49df625517ae55fb5cd7b4a9c7bfb33d426b1d383cc677a41a8b095c57a48f59a1460af92ab8b09c0e7e90dbf4c9d236bc3f5e785c9db" + "25511a546cfaf4c9595ad1f2a1d65432e9e675b22beff63d7131e6068aeac55c15ca9b4c747d0233db32d0d6208ab5e039beb56042c437" + "e891a2646042d59e419c82c7dfe207c3a629f071f2bde9caf876fa61d3c3f5b8407376896db682586dc99a1f895466c2808b4953131d4d" + "020d8f45bac5ccb7b42357bf14a3e50eaef9d6e105c35822e090355a0e13ba21d64beec5d186e1131ed90bdcfb5e9efa40dc0fd1b3bc8f" + "7a05a4863fe74b3c19c8c561adcb3dc3f62542fc8a7ed645a3d47f7d044e4420ce762656e863b559f57f7540f984d49744f7b2a17e037a" + "8f6aa6489016f5a36a912f59bf27abbc12", + + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_043_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "0000000000000000000000000000000050e79855555500000000000010000000000000000000000000000000200" + "0000000000000000000000000000000000000", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_044_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000e010a0d37f6fc663a131cde4c27f458e46f9448c4ae99927d682a370a71ff936859b6f" + "50bab014de3c0fbdeb91aa01969be2b2ba1d11e60797e4b0bb9c1ffd09a56506e923f186b7aa593761bfe2d2fc7a09e6050dbe9bdf875d" + "684be2a76cc900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001bcb1642f1897f1f3" + "bf31291a682d344f5037e5615c490320c88675cb8e02e025e9386ff30574f9edf998ac313117818357810e80c32a6a122cf1d9163ba9d8" + "7e38f7291d3ecc39c5d13e94406de947c860de27ab10e90bccf42f76164ec03381", + .hexData = + "d28a725fbe4b240aba0b2d8c9bf4d024c3044bdb3c505905ebeff937f628b3f1c8d236b411592f4d32f0f8575293db2d3cdc6a35ca14af" + "029a1d6204ff8c804d5621f5732e2d70fd80c714568592b38bcffb875dc7cf428033121a16838f80c0", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_045_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000b4a4455910bcb2b65c2937ea25ae2bc5dff6df61644292c330c5985038fe6b3c485af0" + "7d963b10820242784a7c24d4c46038ae46f17ac854188cbc894982e9c00fac378dea8d6c6297e759362b3948b828d38e735daadf08acdc" + "dc0954eb32725084d74970cf6cb5c571cb16929adb414052fbe2d93cacc9e03d9e139685abe50000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014107018fd65e9756de46584289ddf1140253b48632b9646baf9af201af02a747c424387e7d1e360b1715268869b8387f98c3ceb8eb24" + "f00895edd3d0f80d906760026ece80380d1b2719dd7cf6110fa8949bf22067f8f7d4072d355cb06b20271e25aba9b00730b3f1a549822d" + "a6628ca7118bb4d3d05bd1432fd072604cea01", + .hexData = "1e3401e969b112a4a7df26a6aaedf3ff16a7dff41af6edc23490a27dedeea873db62d8b1ef22bb94a7d5c7116fa" + "aedc5b51ff16dbc2f5b4e064fccb345c8ee7f64cb87015d5e753e399d6f891f7f79d3b017f237a08837795c4744" + "4d3ec649a636e5968f217e524a9fc1a47eb5da4f18c8dbcdcaa3a3cefd6b4ef09eb15d805f", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_046_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c9354edd8b70a5f187bd3576b08cd52ef54468d027d061e45dca25e0526cc89b4bcbbe" + "1f70ee581a2834c9123b08cc28cfef131d7f8ae5ec5f22dd282cfafe922121da0bf578826a09c13cb5bb6500881a5f245d07ce87ccb670" + "0b5d91cab6d1d591b43558d62da7257c7d63accb6c1f804cc8772370d67d32c99911e33d0b62d186f068ec655c63759944fa8500722835" + "a5ffa35c0199ecac1a304a5ad5eb73cfe031711a3a4928157f9a9494a5c3f3b536be7d11763dd5af26e0ae3cb420d3fa3b6f587cf79faf" + "8ff31bf90304c554d1ab4b2db23a4f0c85a2cc793dc31c31ee21b436093900db2b6636e11bdb0f0fe9fff003d3a4486458027c13098eaf" + "99000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001100f583728bd1a11b842eaf4894d046b161a" + "9abf1a9e7061d8f69ca5560ee6c8367991b852bc437dfafd939b07e940da7516611136aff080386bc0f946f5d5c1f6310c856dd76b9969" + "23ea639b0c89c953498ace7e240704d8ff02793a7cd2b0d6fa254728cb17a3c2c33802efb4e0f176bd2a3710361e78a9c81b96a8eba36f" + "e0821a44f82e88e0028ce3aae7f17b295b53fba3b600a358a8321cf80274da7eec5778a2f11e6ec3fd2b110918e15c3a5da5832ef7651c" + "41a160d15679f4ea3bff56bd505f153e013e26a1475370606ddd05e36b76d7cde176eb62af1a48aae3237b86acb0a8c0ceee45a6ca1318" + "6b712e72116fb303775a0a4d8365bf4e35f1", + .hexData = + "8d0cbf0efc5ff64680b435e48977355279a8083567db3ad50208b3ce94103f1794049d7549f968850a81e10504015cde2c433b5285bdbb" + "cf3dc2f65d2041fea52c767210a4060861027ab88316d43ce78c37cf56f1a4689bb1dd3cb28f049ec63af250bea3b3387f2ce7b3779e8d" + "a8ea425b1d1313f7f1316f5b52768209c085b847d498a71c0e7356c05243a6c61975b64d9354993b0d289ffec94161e58872c0f47c275d" + "23f082f27239ce509e4434e555b61b4bc4be22834cd8e9164d86dd20f06e3fab308ca19f33a8b3fc4c931f208c4bf28548e5346014bbfb" + "afda034a173ef3523302ee1605ab6a9e50e1514d780a8791f2c9afaa4f7701017bacc665", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_047_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000c0d7a1b9eae690d22741b0bad5e6abdb786a201cbb01154f1364fd8b5fc23a09621bca" + "d8b997b32ad0120ee18c662a478313c3a5926151575944241e8ee464fa2fe60c79a324cbfef988275afb009c4aa05935da7a265cc415f7" + "212c9a6a92e2e6d75d621742ef8a2ca468aa5481560b8cd6d346b17f1960cafd2b815949f006613e9b0690c61b5ab83cb3ed746cda04e7" + "565f58a888136a631914c28f9f90851ae1653a9f1f2a60215833110e91ee6c226b97ae5d4ff104eecced33ffd916caa2a84877f58db389" + "3f8e846ee288a751863d867f80e7fc492f1d6da9aa0c60dc1774b343a899d2ea6688b81be72c12c3a79698ccb488c8a96342aa8ade6d15" + "46285d8e5fb35c41910584e9732c2756c40798f413331215814d283f6b7f67f3424f11d5da5cc4b63e163b23f9970c03bc24b924422536" + "021532590a5dbce0a0cff8e7052db4529e7b0205995d1bce29ab4f5ed9840985a57fd60144464c28f22a9bcc8f21b009a69b35f65f0343" + "5dd584b123167d6767226150656ac3c38917ab000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000001000187655eb9a881e5e0878b89c84472c6eb3b2a580d9406f8ad2292dfa9c1bc1eff8390bbe55a" + "b97624731e9ab025e17d81e438363fc3fcec1d86215fb2cce4f338edf47981d5d7fa1ab59cb0f5221295a997d7cb05f0898acc6a17af85" + "1f8e003fab903e92a67e6aacfb171c1dab637bc4744848e2f3b0a762dc62d0eeea800d348d86655640c3b76504c22a1a688a1cb120b3f6" + "11cb926eff5d40b8e0b9f27087e40da90375c16e013ca82e82a55634ae5ba46b4513631378412a44c923b38a59d5af20f66690f0d34813" + "ebafdae3968685390b9db7e8482573df5804b6191e0b32c85644f998de27cd58d6b0151a2645d5d309262c63f033000510528f4efeaa8f" + "ba78a85ba2b95d6ae78c2b29c26f0eb2485aacf275b0e7bd0cdf9992b3debcbabd3a7d74e9b50bc8d45223b668d61ff092276679de789b" + "397501599da8e34cdffc40f771929eaf49579d29a3f6bd03b27490aa195d4273ca3248af236ede466badaf076af2960585d997678417b6" + "d00c49460d173a5e5014712099829385d1", + .hexData = + "1d4f65c5a56ae7d3c7eac6da9f60cca30c4ba05e62a0dbf2e5f0fe2f12d359f2cddce668ea4294726790da3ae941bb1186e5fa1197999d" + "37a0413e1694dd534f9466b7bed275feee9137358448d3a6d3a0d22501b14f1e8bc68ab80feb63500b8b19c4b27d2f64abe448bc4bba74" + "a8ddebb089f3d0c2cd56ffe169d9e4f3c77df534089ae814d1e6d0064546282043b4fdfbaf3d4b866155fb6f727bab1687132ca4ef9967" + "ddcbf78ae8d1407b9f1450112bc141f35fbeb57240e99f5ea40a256a6e11b1549b908d66d379a5b744eef01672b891c492b89ed95c7437" + "f6039d56de1434dc78b9b037e574421f583cf282af3c326b53e816b0a54f931eddc918a6e6b86d66f949080d64cf3d03cafe6de46da8d1" + "818a104fd4a1791957c14b345d53ca1e22e387ac33c7b8b3e457b1ed92642280c9ad712a55a5fa1f621726ece801b97fc1c53c18c4894f" + "0c5c34d4fb4322570f29a0d35ad3870d33605e07536d80f51c6e2a2862198c01ff84ed985f109865817c4f8937dd44cdf36e9623a6cd", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_048_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000cd7af64a4ce004dbfadb758f6d6c5fbc9640e00bc40e8ba08292c2a4c8b3b22d08c547" + "3eaa5083b4dd45bda9c5ce2c86789a7c2db787da6a3ae56736c18d025b6ef1b3a483cc25448de67956b94c390c03f44231939d9dff4985" + "e707dac520b00dcf18b6ae18e16c64f2f169945be2f98df16098e3e8ef3491cf310975a8e1a1e5ed96fc132d7e17ce84b9f4e6c2d842b0" + "739f515f0fe0d8c76ce7da95e4db26e048c3d7b911ef6489d66837f2f9fd8d1812a8417f611cdfd44c2bc5fa4f1f92a2eaee6a08d53189" + "91ad7d1d8e146210308bf456862fb691045443da3e2a92cc611ddb7a08f3f40803cfa3e6cf9abf8188fde526d5fc9c664f424dd5b17366" + "143718f2f6efffcbf42f495d1992db9728c38e993b43d4f191e48374b6c4e7116ecaaf63b5016207fa48407df7394b14a3744ab4a825d5" + "b9dede3e4d1271b2ffc2be70594f689a4695ca97609a3341bfb12e8386ad8deb5d9c95c6fad3f5448390ef5db2cd52a4d709276d6516f3" + "33611e9136d1f2de02927aa404f7c4d755dfe37d44ea9c8eb0a911ce25a7ae4fdd5dd38d1610295692f6ab7d7099913044ff7e348d25cc" + "cbe0e0e34e6fe5f4d1984b4070be9e5e855f58477fa49bf804f6b6136dfa60a8a318d11e031fddff42ec0b9f5243ab5bc3e771a17e3a5a" + "648f7d618d108a4b12d4bee7ae6a2ee43f9226e6878a3dd33ec2d3b981b0d22c7b1ea123f9000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100014b" + "4117668ad518b2802353e0dd906d57a227cc6642bd99018610bddc9fecbffaa255ae0c13503d8c45e5bedaa8a923c173f61038a618c933" + "52b2a5a4762a708c900b5161952b7512b06d924ee2ba39c25ec85c5dcfd450032928333ebb2eab140f5aa390741e84a0b030119e3b4993" + "cd15e12b219386c1e49cea26e9720011f2bb44d2a12b5ce3eb502567fd7b6e2cc9efd9c8a5828d4c29d88fd83243e77723bbccaa7d1d38" + "a65649ed0e6a3f40b34db35d51e5fb02d4125dac2ff3e802866babe322c20ece15c06e6bfd808f82838fae57f37aa4d660a4a7d33cae77" + "4a1c4d61dc0f7f983bd04a072b4ab9c39ac73c67b1a4f51e35d009e049463c572b0e5cfcac332a782608d39c7bd4c3be513aefa9bba8c2" + "2df88c40b3635d3e9dbbeaa4ced0e7f53a1599f8b9f3a164e7aa4954141bec6bd0a5052fccffab1ab53c941f9d04bab5eee41eeda05152" + "aad1ac2c39f8d1ad9fe3804dba684c981776ae1c9fc2dad2549708d158cf6350f0c4da940c69610decbfda5398580ea491424aabbd0f62" + "d14646fddd5509005d3474a506d6b919e133596422f60190b10b807b7992d57ae5dca530e30a064553e5cc22a8b98616b56425716eaac6" + "bd700a3e127011894493a86c2c483c04e6f22efb4049015cebd96bcaa36303b41cc7eabdd205efd99c1841c7f1cf6fddd27c167cadebba" + "d8989837da29f0e5c7f1047c222f79c9", + .hexData = + "8577cf3e564f07d0f9457fd6f9e974dba0e7aa86ad20260db31eafc0ce30aeba1bc23324151bdd6cb8b5f251cb40589bd72b896e4da771" + "c7b78ce7fb2999c2eaf5ca060feb616967097cfb69ff734f65c43691525ac2d3c36962c2bca15b041641024fe0ff37c487fff44c2fbb7d" + "7b58203b1203c2adce58c9c4768ab9f1ac07d76aa86a0d857d62a9d9649ebd5242f50753a2d75c893eb8fa3b6a48a600f699004e8e958e" + "874e6a012e4c45b32c3a5706bb00c32924fc50c6d63606ea7a5fe598bdce3c460dcc48949441384b1505e3b94f191cdce10947d8736c46" + "4db32a303fb5e61e29dfe69bd185563d3dcf5a7f86412bc450ee160919169f9d87e40257cb48c626bfc1e696cc4a4c0c6e947a308cd60c" + "dfb6801c2ccc4a5ec25c2caafd0115f8f9fde3eb8d63be36ff31de8347bcc5da2b3202576adcf0280ecefc9e8f83cbcb60684ae5ddf915" + "232a4a204aa98516d6b6fbb6a6b841b52c786f3755577693efb8ef5eeced7a3bbd186adb9458daadae80d28769c79a95041a64ebad9388" + "4bbb36e5387fe4264b92c0b0173f690ae39d6d73facb3877f898a60ef4894b52e1c8de3a8e47b69320d2fd412debf80b6569fe185ba89f" + "a731a5b2cc0231b4189b9c2780256568cd166cf88dc8a67e7980e2ea29871f078ebd92b1ef1570f28171ef61ed1ea7b69abb3aa8abf6f7" + "a8f600f191e2edbaf8d21785903f47cd19", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; +} // namespace + +class HksCryptoHalRsaOaepDecrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText), testCaseParams.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_013 + * @tc.name : HksCryptoHalRsaOaepDecrypt_013 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_014 + * @tc.name : HksCryptoHalRsaOaepDecrypt_014 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_015 + * @tc.name : HksCryptoHalRsaOaepDecrypt_015 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_016 + * @tc.name : HksCryptoHalRsaOaepDecrypt_016 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_017 + * @tc.name : HksCryptoHalRsaOaepDecrypt_017 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_018 + * @tc.name : HksCryptoHalRsaOaepDecrypt_018 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_018, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_019 + * @tc.name : HksCryptoHalRsaOaepDecrypt_019 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_020 + * @tc.name : HksCryptoHalRsaOaepDecrypt_020 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_021 + * @tc.name : HksCryptoHalRsaOaepDecrypt_021 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_022 + * @tc.name : HksCryptoHalRsaOaepDecrypt_022 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_023 + * @tc.name : HksCryptoHalRsaOaepDecrypt_023 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_024 + * @tc.name : HksCryptoHalRsaOaepDecrypt_024 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_024_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepDecrypt_025 + * @tc.name : HksCryptoHalRsaOaepDecrypt_025 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA256 key failed:keysize +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + HksKeySize keySize; + + HksErrorCode encryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "00112233445566778899aabbccdd", + .keySize = HKS_RSA_KEY_SIZE_512, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_014_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_768, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000d10cdba0a029d15254e1b98a1ab3fe28387017976d817ed229a88e521037451768a681" + "bd6b8944d1efc6be41913da3dc8cf42cae0d0b449e2cec4df0537b1702cd9a79b8394175c0474e96fdc7d26616c268059c4d01bb6ffa70" + "c12fa591e40093d988fe0c1d76df2d5999827cb12e7b287d537d477a7a8dae6ce9e6a1c2577d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "010b443221f9ffc6f434f6e554f81373431fa78addf25ce444d751ea39a9fe108f2e68aadd568a53572d20fce7f3b7eab8dc2fdca894b3" + "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" + "5b83ef84097f2112e64d11193da5dfcfbf9a51", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" + "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" + "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" + "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" + "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" + "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" + "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" + "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" + "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" + "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" + "adf95c1f761b56c8ddf2e78e532861cef681", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_017_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000c50e4fe8739a73a3627e504ffd323bb95057417d2b23fac0939c6e3c43c19450b38733" + "19275612866f0e8d349585c17bffa9c13389975916f2235161fca6a655b4c0a3c833789a18a9add01f837da762b5acdf29f296324b4d5f" + "7f586f900566d949f4784b935503b4105e2c6e83d43d6d17e07545eac427be17f0fd7b08fab210f38bfb405ca524877d5c039505a0a9d7" + "c2e24e9367a8a13e2fb9e3e1dd7b72936737b0590ce3cc9262284ed041c2b362ed3b617bf879256e69be4357c027dc66d5afc0a4d35a2d" + "cc6b42344bf55b90985aea8d2604af1ad404fa8dd9014c21da00a2587c82f97045b8be3593a41d71307f5b3295964257ab8d7ab8521b47" + "29dba792af69655296577ca175d974e64ed33881c905649b8a6bbb13ac1cb1cafc6ad61af81d3a0813eb1107d0d953607a1e99657de527" + "c108ce22c06f8585751f071efd87e7e874e01c17714ce73c2b619594119030f54f9c88158b8d64ffdbde582c3340898c18762458bec67b" + "a306aca31268accd72a4382c6e06b35a01f673000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100012ce1e0a3724938937b288804600824004663496048062ee3d3fb2a4481ae42a8caeb3d613a" + "4b6976c32ece4caecdc34f09e15146faccc516ebd9cd7c82fe361e8947e346032b31f5f217cbb291d179e18abdb02aaebd35015fc3238f" + "3201dca91b4eb3e6fe57b5625d8de8d537eac0d9a8d26a666ba158423112e4e9e72f19629b67cd7751a6885ab49d81eab2f3902f7f1c3d" + "4d665792d9feff01d8fca5e4ab2915b6626d35f960abeabd818dff9c681d5d294c3fdf4d409050776c813d1c16b9ae28a78057a4a47e77" + "c62071a0da7d8cef186a98f2c95b16394689534726d18fa8b0526c40d64bb13f579532fc56e9ff2fdf95f0df3ab8493264ed098cb57e8c" + "fe9cbce24a5bdbea355ede53246798c79599d7aee1ac380ed8ee77f08276c617fee8a8989c116407e8d7a481ff77ef32f7405b5736b36a" + "593925cf15c3da1965f84eb4153a7d557a790a869fb99290dca0b4d6a97bc0ed32fa41eba3a27b9379e3f2b140e7d1e0a315af6561c5ff" + "1c894ad34cb998b6eeaeec5d3785bddfc1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_018_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000b3166774620460ff0b4fd912c441a184527d8b6bcf1d4fe22791bd0a79b9cdb4afc944" + "532e948aa190ec27869df84384f0921abf036181369db2ec71011f3f2ea1b1a0f8521cdb75a47e1051e68d3220248b9e68303780247fba" + "99610d7309a99087c6da95a0f3bd5abdf703693bc7285a0a30944e132015370f9d263f44b8b2d05ed32470096eb6c7309e6c62d74cf99e" + "72ee94e8e1bbbcc902935762c6a5e3297e4766fc49867e7768f40902d87a219d92c196caa030a206ab75c02a4fbc4d0803d082fd328613" + "9315489f52b591caff2827d70d8839f47fb4195dc6036f3718987b56e6c772a30694cf983671ad6b93e1ec99ff94125a6268b1e556671d" + "11d41eeaec4c5e642534243dc5f4edd64190dcab9497298d8101ed7c3a97b4f28c892cdb2e3adc67bca83862429d82e8f6c40b72d7dc39" + "1b214c09da284a7aeed2a21914dd0aa3ffa0c97800b8c37198e92a5ed1c12788c9313d3bddf5436cf17c1e481e7613fe8a04cb8e5c14f9" + "8c450f4df4a3f77e548615adc6face54baf5f60a140759ad341aafe0187d9f05745f094b547dc4bb3ad5b2be64dc10e000e555c7a09282" + "e7ceeb8d99e1fbc64e57409f644fe5e877735695222347ce556fa340188ed74df9ebb26f7205206a94b9eba96da988e13ad273b931a9f7" + "6e501f371e789cb2a1249056076e50091949bb9ace7af104cd9db3e03d832a4c3e6fdb9c87000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000170" + "d46ab5ae9367b1082574741865e926fef9cdff4c6c014a50f7c70c7488958b833ce0e92f6db2b1fc266cf8a94a22effcc970446c12e05f" + "d29749d4208ad939bdf1b5a2fdc8e49387e14cd2ecd8847e2fc82f33213db664487cfde96199daba942e97205c291da76d26461c460ebd" + "7934d13aae154a836a1a58a1ffd8d8a92d2f8eaea4445a0d00e71a4095b4e844bcf8111d33804dc80436f8827009f171ce5ef40a745dfa" + "ccdb9ccbe9044c60ab01c6cf115cb9a8973b5dcc64d17f56e121ff2cb80fef0a07e30945dd8d5384c5a8097df92bca80cb52b9aa7458da" + "4a8ba540bfc0e58d5c976312e06ab2518ae961dfb7f56348dcb77b6e88db9bcc06070f871c5f38d10e16c686e51a78a7d54a78e7ba0d5f" + "a5c42c4a401529890f5f697ae567a0e5583f49e73f2ee735dba5d0b15df3f0195a48de70120eead966126f161bb57d770cff988500ed1e" + "49739298692a55764756eb3930ddcd035f36f121b242d21bb4088bf176a3a98045e25ef9347d2a2438fedb024765d80b7a6b4d5b0edff1" + "dc96854afae97c3b6bb40793f78e93972a8080b87934ef9e014087ad5c794dfd6313cef45d72d9be592846a5c4414b2570de994b467db7" + "8f068d0886fc1d67a36f80f556b5913a55da31fc193718e74dc3275c224875eecad8a353183244c4c73c2bb6b96a5ce84c5c8992b43eb7" + "2ed71af821a658f473f0a3a283f40d41", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_019_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_512, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_020_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000ac66380f18d9dab2188de40e6bb622e2da123e08add16b7c5dc260dfbfe7432c390698" + "e3bf34e7e237c0777e4bb10a29ad8ce41172cad65dfcadf25c8dbf9b0e9fcd62d5a4b7967199151aaf97df9eaffd0a2f96cf324c2a6001" + "7f5f29d59dc100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100017ac81636d2591dc3" + "676f6eb3c28ca64df047bbbc8ca6b0a99351039377662a560d8b204a5b7c3f85c27525e561dd05c1bbdb5bc9bddede40e55397fc15034d" + "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_768, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_021_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000cd1a15f15683bc8bb38041d407aa1499bffa2831f94f61ba607a37da356a664e0af5ea" + "01a43052b1b93221208764c02df86d69ee2475192b0bee0dd08246a3a927df959e3e2ca68558e3e8f82c1fbc231524f3d78bd2ad1141db" + "4dbf5800a031f254a9f5eca58169bb3daa787707863d0f42a0a868c1cf882c995965cb4317dd0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014145f0ffca71c87a8958e31a508a1f5e430ba0e92e97c5d963c4e1ab8f5e5a4ab2104b35d484107d411c2410cf261047510db92db1ea" + "9664edba0829789c748ed96740a56894f7f085ce43761b81e00738337061bb7f7fd27318c558f4deff8160c071c7c91c47a3e01950198c" + "ff3985125a1ae69abddb80834bafc33944edc1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_022_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000d44c2eba9c805a2e00397ba68b54ded3d626b02b93d72664f97e023ecf5d4974388aac" + "ab0983529acc1302beef7975cf9db43a4a422b258bc3db75fdba50fd67bd009a44a248b712638589c6d5115aeb8b320c04401400c3a0d8" + "6684337937ff2259330c06dfbd652497fbdf5722dcc8a4d583f59ad1a02eca4a964516a23a06c4398d4edd2c977e7b85d41f303f62bfb9" + "3ff65e9e837e8d3c6f1c9c9d067a0df7c36a0c196349d2cfc1d82c5daa60935171e42754447ce60328abbcbba6078c39ccda078cf88adc" + "1dbfbc645a401fe386b57b5edc94d5bc8fc7e2c3cac6608fe8d91e69ea9fb17f6b7b42ae794fbe82e12cfa4ce60a11de5e83c315b902d5" + "c9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100014aba8a545bd47e69e4e0571b37be67355013" + "8c3dbaaba83330f35f1cf6e7527cdb8e4cdb63dcdb0dec39e0e48eed454010b629328c7a1d9c461411437ffb144818ea86631470de2855" + "e9e2a69fc79d267e77de6cfc954df38ec1bdcc59461924f0d54f37b38fbc5e46f44ccfc01f60722c3b9058bae7812817430c0443c45501" + "fa69778115a748a79b89d1e99c7791516a2f7d19114cbbd4ed7827b51ff8caee4dee84f16ed0a1b497513be6d563fc5ee7d0891c523e8c" + "0c0be002f7edc638607ba45647166342b004d1cc7a31a3492d8980b9a3f2151a4aa2cd8bdac7b1652d791e6915730bc9de98ac1a3b5fd8" + "2c26ae2da515146886c78090a7aa8c31ecf5", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_023_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000dc3d6c0fb6da1679390202196baa6a999f217a7ed8ba8a3d309bcdff755094dd09bc41" + "77ea6ed014ee412051b2c02f851f32e4400c894ec6da6b510d613536c32f2dbce41d4b9196c24ade4edbde812e8eb2a774bad179c7bc4b" + "aa338fa2cd67d5e6b868b042b7fc0120fcf2e8e104a3dbc35c250fc91e486565e8928d5d047d0bae93ff09d9351157e5a000073935b09f" + "4bc7e5b25e2287f44ac8daed8e0e5db021359ec22acd2a1d374d82d7ddfbedd7ffe6a09e52fe8d23a751665fd8b36a456fea4d69900a7a" + "623d92c6a28e56d80561e3123a99c49253058177cff12a06c8e4d77563f0367f5ebaa8f5d71750c721fb6a6dee9d28a97c7474692f60f5" + "528f3a1e02234c93fd895e62f40a9c44ed62cf37c52e1c4f582350c6ca7991a6468cf4dd75b556cffb09c6b69c4719d00196f4bbe1dce1" + "204bbc5a673fc81fbac0a8e2fbfc7d4f87ef3e1a501da79226ff984e440731c7a2d8882aafe3d8195dfbcd8c8665e9e1bb334fc9b64ec6" + "b22f38015a9e797b3a509b8efb44541344a64f000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100019570a40361aa47b7878422528768c21e6d08b56a9ebaac946a883dd60a0f5c834358d6ff7c" + "3626c11d0d59d5b5b98c4502ef704b39766ddaa6584d4e0bd8a4c8fa1949e36b315c9f744482e5f570dc2cf02caf4d987a0ced078a3bf9" + "f28ba05ec5986126bffaf5866c69aad9544562f5a067c5fd6be1a6c7aeede04a98db35f1775cc51537e4878ab61e9c5b888b3c301556c1" + "53cd9cec475deee4ad10a5e47f93c464f2cd8367651d1fea5b4f08542a85f720d179bc8cf6cdeb796342c3f2b0756daf51eda214a3e49e" + "23fa8682ca429d1f5bdb6488baa9595272ceb55517fda0eb723256c50fb151a175d73a117508213b7e6d3be0eac0f6c349b5af0d77f22a" + "5bdc22cdab221cb8e474011122e67d195a00ce9dd821242df8eebde04770527d559370e93b7f8c7e882db778b6255d487d2119acfd81bd" + "0363e27d27486d14df9407e8290916064230a638782b4a1b02582c1841703f88d0555357d9c0a2052d9d6bb7d7e5e1302c466eaa621e4b" + "4c6b42f0a1bf2588695018a295ebd7f031", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_024_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000bd0d9010dd30b0ec8c396744527127508359e0f12aa4b8b09dc20f42040644d4b33f90" + "de38ce815367af5a8cabf18a71732d569bcda767767ae0b61f38108a021d197b2e097e60cad6ff186a3510667a4e19eca53abca79dbc57" + "8e0d30ba42146946c1f5fcd6204e17252be83121554ca68637e85e5534d1f2c943831d9a65de22c70812872ec219cd2ede8c8c3e78a5d5" + "250b3edf4bb4bfd9a9232f2dd2902b61eca43038d354a365dcacc623de3b062207f7807c9d877a603e2c70ae129c5d418fe52f023025d2" + "68b0627c0dbf1488fa078fb187b57c17c86a43116f94622c5ba31c4ca771428fb73c8b9ee7ff21962dad6b2094c83823f413bd8ec23648" + "186c34a2ba9f0d972af78d7882bedd926faffc6944c4d4211888fa4a49ced7f558d30929041d93a8c5d2275e0330909cb201a618f5a747" + "edc459189b7d30426c49a0d10646a10f015f1e418370874ec2ab0304515178c9fb4425b7c4747e6fef0981b8d599cd3c1152ed804a79b8" + "9737a5344848a4b36ccc9a29b7fd58ec854a5457fb9b24f192959050ea793b8f17d27cb8cd809b9b87957889947576137868bb30bd4810" + "c421b6e937fbb554f9345e266cab23623970f94df74a0a6321487fa655933f45a1fdff7252aad1230e518503ca22ff815d6427acdb57df" + "b7480bd4fda526470c7a3187ea980db8b75b486d77844e030821b804f32b56b75994b96a11000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000116" + "9c2ea4b5af83196753de33dfa044d16e442b90ec46b307fc761f19081e2fd13876dbbe9810aa8aed159dc0c137ac15116f54b2619029e1" + "93a49863777312ee59c89860d325d831aa30ec1c97a814798029bd91ad4aaec940a3400bf7cdeee53e0a065c8316a0da760e2e08210819" + "898748fa1ac25d7269c19dac835be10159e5d2e3f64350a64a2badf553ddda02d7e27c01b24d4662a1a748813abd423797d8a852a2a9c9" + "2c90363884395644d7ce4df7a1f42df33126c3a7ebecb604e7ca8772cc38290cd5192b081d5f34cdab890e4e25335845ae47b1e2738efc" + "4744ce854f26ad4c4151729ab995013641df2474e60eafe0db694b737f80e637f801fb25223a924e96341ecd43fde54a977bd668c5a9a3" + "95dfe66562891c211e888e68ec740f05e5cbf3776774689b83453463a226d4dfa263dafee68378af41c5391bea2588f356799578bc5b67" + "e6382f5739a428589429c9fa66bc8a418ed6a353a09f92efecc9029f51eedf9f98134310cc11ec064fb6e5c9266b0aa88d42e8e574f3fd" + "2f3da8e34a310324b42bec03945c67b54915f82eab1936972a2ae42ac1d71f3c552b39a3a62e25b7b38dcab1c4b71b89445dc563a158b8" + "614a5d4c4792e3e9c1e4aad4a854930f63a476441d90422e1a671b0fbbeda2015b189756e421c8e7a6253e354c7e116ed50cb410bdedf5" + "5689eeac4e8eb71c16fc15829b821b21", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_025_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "00112233", + .keySize = HKS_RSA_KEY_SIZE_512, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_026_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000abb40b8b0a75bde0d4b54aac6d680c7017c5988f76796cfd1bab57d3742fae7a0df13a" + "c51b64ebee13da5bf8a59dd5890671f2078778a6e8e2f78683ebd9a36be36270d5bd2e94d9fd16c7eef047dabe81addde56a8c07c057b1" + "87c5f727432900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000148d0ed08452253a9" + "126be3c4260db7209e6434e3ba599a67e8a10c78e750054d4bb65eb7127c05360d035077ad3cb73e5805aebfd28f2189acfa371768cd18" + "c301fc00f0981e1c14d377736068e93e8367c4f7bb0fa5a1aa3e827b2bfc52d595", + .hexData = "00112233445566778899aabbccdd", + .keySize = HKS_RSA_KEY_SIZE_768, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_027_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000abd5067aca33441d55adb08616728eb4fc6fd2a2305b65d844e649524e33f85f7f8443" + "62305460648dd18113b4ef745d8f84a1317b7f0bf2fcedf3a98a163663c37cf3d1735c5949cbaa8109e1f414633979e5921b54e92d9aba" + "955d4611939be832605d80c21e7d1df9d74b231117255c34457a94219248a3ffb26e5f56c1190000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "015223a2d54f92f21c93b85389c5713d8686a56daada32d69c6b5329f98e2889b21ce2bcd35307028d0ebdf755d44822f81682f00b175d" + "c3f883afbbaa6fb7ee8738ee428b4ca66b9429a0344404b2b7ee2dfe5e8b5e02911b588e1da4f1c966eb061d6cb7fb94553d5119aed7ad" + "256eacf50f7179fb619add182443ffc322a601", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_028_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c4f60d18cea8dd8e0635c77ced7180a2e876d85668a2f93eefc831bf5a7df549303737" + "7c78ef3abb295a0a3c61c1ee95200c5422ff0e320596e5911f40951b587308182a1564c852a0dc8e4949e01a7a63459f1eac07d46c9728" + "e865c68fb8cc8c94d087066e84169089f1bd1ca9279729dc2330182ee482eaeb9fbc4cc131e9da0ab86c161e7a019ea08b6b2899f8f76f" + "8dcd27e65f7c92ccb0947d6834ed05242b08bd4faca3910119271bc3de7775c53acb92aad7c3d323372c4d149d140ac1f66172d6a932ee" + "80bf123a4558c64a7ad25b912ac233aa599eda965e271ac065c68909634e18efeaa951c35b2424298633c3fe8783deba92e22be1dc662a" + "e5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001454527fc068a9b491ce40321ebbc547a76f9" + "7d427e907aca68b866ce9ebbd7ed829898da1d0a3e049f197caa19d383de4ca4295f1986db8eddb02566f166bf744f1894af10511ea6f8" + "ce38f88b93d69c1e97d8cb87c345315fc4525fa102e102879abaf012120240915b027af93e809f0868d4b3507e057e09b30ebdc1dcdc79" + "7d30d27f750c35e1ef66d1aae17a283aa29d7f0552d49fc8b2792cb4c3f8bb8fc437d334231213c2b0d671e63502a2c3b95cbd1b424c39" + "1c17ac851268117c736d2dd28898c69c0c8467a5588b2c6e1d8bd21bcaacc524da0fafcee2d869aa0047a51c2c7624d4b9400c2b2109c0" + "5b2b7d1a9141887cae78911e04a35adfd341", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_029_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000ee5f706a43d3f09582c6f0a7677e2f7695ffd50df34c0bdefe9710d3be0b08b6225f90" + "f4b27bf4163cbfd0e088a85cbbab9d99ca499a7e33e46b7c8dbd49dc5c017c18409887ae7c67529ba4b76b534cfdf7a6b9f7dff7411e35" + "958879e8c912229ac0a30d989aef962b97e8fe2c5029db5f51ab7deb6e4341063853d3318bc21f799d77b37302e976e2207f0672cb828a" + "8b609a996dd519d54bf7dd051286b9e0b0447e789de7d724ebbdb61c5dd38b677af6470bf5dbff39ee5f7a6f811772ab9d38f1c42e371a" + "6698948e505e3b096917c658aa5d0a48290f98cfd7219c324a6bcfcc66e244ed48013b52eb5a7bef7786f80089cb4b2f5ff1a8365464ad" + "85f50e962c08d1cba6c7b2ba0dcb6af91cff35d5d834c224ee0adb6c4656ec575cdbce4fd60bc6d6d05597d70c92a2673e24f94f515e8d" + "c8137e5efda4d5f8e51b42d6ce8186472bc92915da9995809b21d2f371c8d0840802af0afd43cd76cc914eb3a958f7c6bf05ba4705e2cc" + "c8f85de9da4f5439da35a639fa326273f228a9000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000001000107e57b78d9b45ca4e74725d3b5d6f5458d64832f4a1efbc9b04f5acc58e04eb291e2ee8f5c" + "964498b3fc7ab3e57306576530fc563a27f7044b0dd07b7588cbd6f469a2f808d57dcf3b30fe5cef828ba8e244e0ee0a2b0e2ac710695a" + "b307261a06b16fae37161613d7baabf698ece8deea1877412213b97c5adc14e399fc6b2fcc11204945d58a84275f084a8cf12292b97a32" + "820c9119dd1836c3083c51c7cac289b44b283dbadf62a6b88b1ed770d98e5d01698b18e2e7ca887dfb3554666d62a954f1e99fd0006b1e" + "8b67eaecbdb0d3f918a880f0ce5cacc614dc81cc2029ead91ebec3afff48e704827e41316a55874950d0801f04b55177cec74c32f8fb87" + "c4102d8a5a8a7440416d1664587ec80538c80c22ea0223163f44c9f3ddf3b504620246e26d58b17bca0714ebbf98d916cea6d88dcea325" + "aaa7a22d184151b4285acee2ed6c064dfe0734e796298a8a5acb8a84462487be3b4629306f08fa2e507427d9bdf2a01b106fa832804861" + "012515bbb4503485c38a5895dd5c41575d", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_030_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000bd242191c7b58734f519b77d69978689267e81ceae91c334890fb7e8391b9971947dc1" + "a1919cf3e60cc783ef51c3702fa2592f4e0060a5a03f2d3737ce9f2f6813b6fa2244835c739d3b8065c52a0aef6924f648a4a7d65e49dc" + "4d95c7265a48ea4ecc231af6b5a78acd94eb29d1a59c0c474510c8c74c087e89dbece00273baf31d2c915357e301d72ba33521537c3a19" + "fef215b1416ed04cafe06c85c78abcc60553a6444f0bdef3bb58864d52a23d8447da98655632f8249d4602b1cb99f467c99d6429bba5d6" + "cea31db9548178312db72d8cce5f8559b76b77efec3e19eba97eb984ac9232b9a84087335bdcbe2bd50d04e70ca0b99e0091b8a3b2818f" + "905b9e894858db311cae379946941adb85b03ec13d53b5527ccbac90bf8052bb0ff33becdc1f2f493e4020ebbf1778dfae67942f8c08a5" + "c069647de3532eecc3837d3b635c7ed8eadbb60adbfe52792b4de89ddf410a98dc59964dab256e20bc6558cdb7f7b7ae559057dd0f116b" + "9250af84124a6d9d72ec69b2c756a1e711b6aa62a5a01140aca5e57aee6f738eb3093940cae3106711596b080619d34390c776804551e3" + "315812b23a9e309f5f2a6a204516a4585721333b7db48ce6545325030a14f729c2a095bd98cccd21de27f84126c2e60ce261fa64879ef4" + "dee4e40883d67b5f6389b3ae1e8c9018c96c2a62b5844bb6f556aa433d77a4fbe3d0261da1000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000184" + "77e5bb0030373df3dbcb135efced10e990f8c114aaaa190555a8ec4ff2f0890802fbb679118010c32a8950f7e6f58fa718e774adf70289" + "353629d24038652f737f57b8e05b5048f8fa4f76f79bf684af13601a8897b41fdd831a23a89347f0818a2696ffaf8292913862f0411dbf" + "eb86fdf37549e9ab6ad7951e1eccd56ad0a8acea25ee45438c6a72f99fa073a431dd3b1db9eba774411734a6eddad4626acc15b6fc6023" + "2ca13dfb1c891366a892852efdfe761ae51fbe25187f929e927906a7c24000aa97ffd6418ff3d927c4524d3e59fca01d6e7be366b55da8" + "0be68392f65a607dacf731e891291fe35abb265fd4fa7607f6198a7bc39399b2cfe30775240fae0f0db1239e8b072a580f4d5ed2a9194e" + "31c11bca7c6903e36e2224a9a9b1926dd500f1aa6cdbd2030ace1fcdcee9aedaefc477ad5bdaf88787d53cc83d2f00f25aa0f57afca753" + "de2368c7f70245bd92ccef7a30b9f799a328f658d7a285265a3f03d10eeb7d4a4d42ee202ee2f54d182fe88d46608949f337b1b7a2691b" + "0db4e8457ec437f921431cb40adc52163957bb2da94a4b7d6f80c38ba5d0febe3504826f279795ba72d358882d932e9bb85f5bee0d46b5" + "e8e91bf2940ddd8ae7ef274f562eb4d47e380eae720f05293830313bfba820ffd71581a95cf50e4429ef9a020d43a09fa9a55fe1b2f6f2" + "936d4168586db9160b14f3c8844d81f1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_031_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_512, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_032_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_768, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_033_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000da938b9dd72dd0646cf4a110789f7576da281c5bc54848edd5305d769798f1d50a9fd5" + "9e0881824a564eccc9748932a52ad80832c1a5b3048fedcf2767cb7331e21a9e69472bde86d26f0955a4c80b4d0e64bab47404869656bf" + "1d244f2f30daa7b1b80e8a17fa1527f54562a658a313f63b91a77e00504a001b0e2129db181d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "0120293392def57bc33b10e79e0fd18eac153f6fa4c52b74a7a205c2cacf558ec7c50f6d941a364c207a00903b582d53c95fbb77c15822" + "f46b486e3a5bd6f6e594fcc0036be7b34bf6ef1897f8bdc9f5352dd9e47c83ca4a8e8670390cffee57bea3c3529f382d76ea7b8b91889f" + "87eeabfe6c35dfb10257df39c31d3467dbd7a1", + .hexData = "00112233445566778899aabbccdd", + .keySize = HKS_RSA_KEY_SIZE_1024, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_034_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000b7e7b8fe8778adaac50fd7935451726c84b0f60dacbb9462140d50a39d065fce6bacaa" + "d29bd9d6972e732304c30ee967676d8062c56e5ba6328e651a7afba7f0992806d08f575389683f412a63049c49200f42f9410651a946a5" + "130f3cb10e6d8e04520af779b4d6d192578540efb66687a896cb3d0839692f4f1853697e9f8def35a94f6fb206b6375ad9e6c5e8c27eca" + "4c25de185ded5793d0be50f882a124c4cf9774621872725e6365e6525a2d61d8558ed385c6a15b8b94b5548c42313c51229a3c3e5161a5" + "d0c573808a30ec94f5ed907d250070b069a9ddf2ad666018a9f549dabdf8f333c6414c9acd3a3565770eaed7843cb775d22f7d790b97b8" + "13000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100018d1063a86985b9c0c9d3b30a419d0fe6098a" + "2bd2a57265092e54604c800009b12e8a8da56b029745f3cd41493fcdca5f14c8bbb807b4f4fbf0bfa4f1c0f0140bcb8f165b17f8660d7a" + "373ae72678bce0a284d25c9af21be57a58d8dbd13406db261a4e4c3733d5f10963f55a334b2c604d229638632251d74b00a2aa28bb85ea" + "6e6fa3e9d4fb4e8b2a9f4aed3c2e84e488197383c457acb426babf2821b40a7a2b8c9a624964e8b223f20428e9d02ad13ecdc426858c17" + "2070924068d97856b56ffaf5d47e643bcbc39d85fa425d93c99905301ff10fc15ec2c2bf49228b69cbb50895ecef1140cb05bbf314157e" + "c8c21796b1eebea225357a4a8b89385eb141", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_035_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000ae9c2597d382b1cf800c1066c2f0fddd8e6e0d3d7f60b33066291cf20ea84f9d54803f" + "e6829e80799989c4b95f92424237909b5a1cfe9f99890a98e4a80548523276c4cd421dc8220c673d21255c29daa8862551ab5c6c19684c" + "8ab11ed43bae6da8184a0a97791f7b3d7b5cd33f7cbd6b2b4847f6a8bc3764faa7593763f5a3fc253e616e73fe26eb08aa3060d40be98e" + "f95c39ba7d8ef3528760b8c5c9c8b7a7f74f87498e3c33a76d4c94863fa9a3d7aa88019eee6a35ccc43d7dad5f8a0fef2cdba741f900cd" + "53e8155c4a90f4f79c7892d445e7da3d6a2496a4ca32ec8fa325bad6ab0bfc4911bce78be03ed0043f7c5fee60d4b10c7412301c6dfd36" + "8093b9ab12dfc61d403b7905ec78327b384c94f31059021b6cdefcf8440e1ca74ba5eb98d27c158825a8b7a648c8d0a23c28d15eec8924" + "058ea9d08fcdbc99f2bbe017228012861df4fdadfc20f58600b2240c7a0048ebb2ea2d8f846a97057c6fdc5b1cf916095fd51659063400" + "9bd94a988ffcd2007ddd46aad6918bbd3bcbd9000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100014cbc00655da56500fc93d0ad6864421c98d8526741503ccf3b463c1b4047c55d2de282b289" + "9aa0794ff95483e6b53efb1cb227238df4742d24258d1587a572a7f4d76f1b893fcf50ef447b7fd28c53346db52e375ae86df52879e2c5" + "7df7e5167dc84e8c536547ec86db79184d19ec76cddf228fc59d57c1bc55cf2f8d0117d56e1cebf22379442ad445658d873008e0265dfd" + "a2bd0b2ac451f37e95150edd6fa09835d20d883d7ab1cc7dc813cb6c80bd698b05b353b1475d6aac5f4bceddbbf3040f17f701e60a945c" + "cc12e90354b6c508084570a3058dde4e0253e961c014547a2ce41c5b9ba04704329595cfc1b451736658cd3e6734e30864f1a083801c14" + "fd309c4e116329c5f0d6c12012126267dff44a47d4d6fd2f6e8a4c0c50e14bcd3cd856ba26894451513e139baadf3a2f992f22532afb8c" + "c7607413b7d42230c8c06299b46117706658653f838d32a8de41d8ed7ea779ed1a94029cfbb3f4527bceb5ceb700fa20bb5e5f463e17c3" + "10ce7fe7cef8179d5cf7924697551d7301", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_036_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000a92637cd544520cdb67f0aee8c620047937df05133af415e2644873f2a04a8b5d1ed19" + "667e0aa5b0a859c0f881f872067e208c98ce775de153ce95593659e3e4133229749293f83af9d5b6d15b35f0582a3b20bb7d243c5b161f" + "a1326ad5402b1bd1f0e7da929ed5601e5abbadee4243ed6bd364aee814788a6204efc2e6a4b1172f79215c02c49ab1c3e2f9c9cd03e35e" + "27acb023fd724095b0b68ef069a746067516093168f84d6040c64d448680bd01f5af31e78a57b0f6e36d4274f54244d5df0304c3fc9d32" + "083771cf322dd31a4e02b9a55caf68bc919848cc126802e5883e015f6dc48f9de821b1c83142b674a374fd7d0cb37483824ea9efe0151d" + "eab15e6ea8f54262b80b6036f6151c82ee6804d003269163ab52bc62ef6b8e1649975bfae50bb8b22cf4f1cd518c9e11aecca3905bb1d4" + "866fab531ba1531748e8722a7d12d3ee52014ad6919f10feccaa1bc3386b951bfb8587c7694cadb9d3be984a706d40505bf7dfe1963efb" + "52fd1ac8e612a42ed934b7e0f132b9118ae13361f914b27a5ff1a7b0f0c27788d737410247c2e25124c982926972b87f35e1e2a4529235" + "04474dd8981ad18b0424ff40754a271652bfb35acffcd25c46afd5a69ab1365e7259b05f04b12bebc7ec1361e909359deec133c7c4b58f" + "bfb2b8fefa21df15955e31b688bcdfb1e857d955af09e5b724b9a11dbb3cc7f1418f09995d000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000104" + "63e68ce0c40e8ee84eb1d4f135d5f605a0fe2ccd5f9e1db8768ce019d21722e8f8f370d292aa2c44a257bcdb7abc52e8d125750dded143" + "f8ede2b8770dac398e39fe13757e7bb1e42c24db9837752e84a2163e67881a3ceefd112d02d2d820864f53a660e8ef5070773939a7d108" + "4d450b48685395d87a2c7550d57c448a3fc26f4c008ea7cfbc8822a27083495bf179cf23cf4a8fd8784eaa5082b340bac3b9852e763c9f" + "11dac845c61fd948786cef711604009379a5313343f1b6a16affe8612a6de43c5944242c743ac17da8fe04ca5351346fa51347e020fb92" + "faba208501befd6016faf749401ea2288d27b92d48eb0f64d5ff8f2e41a66d806e6be151b4f2c409e0b8035ea2d63e9baf538a122e5e5b" + "02c41f11c218cb4e86665c11efd861a325a03fce577de17928da5a2fdb0786de366758c7d89514c3136da75a7095565e9bfdbe3932606d" + "dc43d631025828cb95703d1a7907c181126af324f5801531535bac8a6714204e46ea683d287c4c52f92f0f73715a5b8311d136aedb9a69" + "608e18be69e85a8c12b486bcf72f9a3c1f1dc01b5c77defa6b66999eabc14337d39183fa82bbd9de7f12ece728cc3b523e342c21363e52" + "4c8ba57b32835e06b8695022991d123afcaa7c6bee5802616b8ba5507e1276c0f472feedb3fd0a5c3f4bd2adc986c78d079d210537be05" + "a47eca98a7546b10c94e5f12a81b0921", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_037_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_512, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_038_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_768, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_039_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000d10cdba0a029d15254e1b98a1ab3fe28387017976d817ed229a88e521037451768a681" + "bd6b8944d1efc6be41913da3dc8cf42cae0d0b449e2cec4df0537b1702cd9a79b8394175c0474e96fdc7d26616c268059c4d01bb6ffa70" + "c12fa591e40093d988fe0c1d76df2d5999827cb12e7b287d537d477a7a8dae6ce9e6a1c2577d0000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "010b443221f9ffc6f434f6e554f81373431fa78addf25ce444d751ea39a9fe108f2e68aadd568a53572d20fce7f3b7eab8dc2fdca894b3" + "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" + "5b83ef84097f2112e64d11193da5dfcfbf9a51", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_1024, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_040_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" + "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" + "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" + "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" + "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" + "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" + "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" + "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" + "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" + "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" + "adf95c1f761b56c8ddf2e78e532861cef681", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_041_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c000080010000800100008001000098d7dc7ba96338aa0f01393fe4c848f9491c9e6851e8869eac27736dfffc30347c7723" + "457f79082f61a2188ebbcd1906137e7369f5e6fa5220062938465456a46367e9551c1dea7f616343f2bd6078a89b24d10b7bc08fda6d95" + "fb9414bdc869e3449abf06b314149bd5a6f0dbbb195476ca4ee29ec65405a0b8f1225b890d6e7ee2cc39c1551f7a1fa42981bb98cf5939" + "83c5985bbb13eb545d57c46e9d60a05b50d0bc3518606ba5735c00607068556bcfd788926f0660fbe386777befc53dbec3a26c61405dc5" + "92da9c8aea3b87299e0c186eeaeabfce7c4f0a67fe952411fe62cf6007a1c28eb7e91316d72e054857136b8b75b74eefae1278adeb5c60" + "ef79f5ff9197d67cc0ca8564bb6110bf5e1e2fa915b05fd9d6bfc74b1fed176167638c3af06f5b016b5aa368297952830870de51040160" + "33535b0948b6b8c548db76cd13dfc20742e194ffbcea4c491f884e4d598987b0ef86a11b771b8e244a9677ee29ac104588f45f90c9b0b8" + "2145ee35c324e6ef9007fa424743d00e3cdc39000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100014ab39e1876967f1866d303471e2b61b72d2ba6a477fbfce7ca5e51c55e8ac488b2988c0da8" + "9ae00c405cb841f2b9f0540eed0bbdab28e409858b5d541ad397b12ac09bc33445ced9c9207a1246cac2ce2d5d962a55a6ace8660d1af3" + "aa1b83bb750f8fce7398cce4b1b17fb152c3a442aaf8800bb4ec5c1e900a3418c5c23b6558f0c23e2c26cd86a3b6596f05e04edf5e03f0" + "6c61d112903f208c07fec43e78c188c32c698aeb7d51550b8f479348fb0f017b674da2a3ec7cd01c65839691c0b58139e1b3d827c3961a" + "26d9d64fc676955e4b09ab58d4cbcdd15d34cb6da228a9b709dc87cb6a0f6826303e082aa16c27837fd62b42682313e3e9dcff90b06aa5" + "318704f4260c03c41ef580a70a2fe4cad7ea2a4f4793173e0c49d7995a04bb97d8bf77fb14b0efb9c61ae334612587d76c92f7ddd2ed78" + "a86830cfb4715a02908a6bc917d8b262349d19427c58b0d26be9dd105e819a422b738bd86a0f69f41d668fb6d33de4fb784af5e42d3168" + "ff5fba845faf39d5e65cc388bafb6af671", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_042_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000b84a40ff88dc4d56d93df76a10bbcc0e6ea27a3256cfbbb2b6f87bb9735752e7a51893" + "5d1e8d40777736854204be4a273e76378653178e5201a82ea19e46b59634a424fc6968eaecb76dbe53164a8ef6b822193ec6dd6a7d98c9" + "ea5dd3aae031c854347c5a883b18baf6541b330ed09947adc4ce8974c9534bf572d4b73160491add3d312afbd2a249685c00b995262349" + "dd6ea374b91403be3b008338b7e9fee6f14dff5bbb57b1414a1b912858bdda0cffb2dc0f1a543882ad0b08a95aabb7f4174ea9fa487e1d" + "ac6bd3a531d5ecacae1252e0b0e8ea40d0aa9c691db86df1dfc2c01afaf41ac7e624e6384d0d4bb603f8b19eccf80de9125b868ced158f" + "56712b3b5ffbb5d981e1eca28bc6ac81f1a04afc41032a8891fc5d3d25b86511f6d80137512b9d5e04521e3eacbd60c5047cd7c9d009ab" + "4fd4657b41f28a8f0cb51c73fd89a6eeff0c031c273750c147f12806766791c9cd4beefd71765ce74f5fdf0689ae2ef04fe34931078484" + "04ae44c01f5ddfdc2166ba9037862e132f01274800760879cb23fa4395ae0e9c5380d925d3fcde1782b754f197bdea13eebeed3846eb33" + "5145bd67baf2c10f6379c0321f2abab2e33661c153f4c08eb3eab0897372f43b4cd4dbd4d9dd9487705f4a7cdff310b3c7df5d7d144061" + "40b8a915f569bcdd83b87e8c7638d80d46421b41d8507e4e76ae6ad307fb90fe58cc62d0bf000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000121" + "a31bfe0842fdb2ce702b0aa70740159a47f9b9da728c35f083a6419135ed21eed66f7f5da6369017a851e65ceb46a9a712f8cb81bb18f5" + "0aec61a68a3729c9c2cdfb1a3f3b313607bcf632402d57aedca90ca692b1b3503d650d6c16c867a76e8340193a8507145a7bbf9a3f5582" + "e99755b648647a768cc79e8359241ed50e42e302da4898323800e21578e466bed14e1826ab9b107500c1e60f0fe4785d33737fb3d6da2d" + "75b21ad2a5f976bdcbd952ea11016d9846ab11def7d69ae2bbd915aa73673f11a0435647501824e281127bab48894e8114d0c3c5804b07" + "6bb455a39bee687e49b3e1acb62b77374927fa8efb03a09294ec25107eb82e5ccfc49b98a4c5492c45723b2054454726771e555c105994" + "5d3c1ee5b03bc514d44da961420f4c82b5e6fcdd8849b2395bc9fa1487c0a7381ce651806eb384e90445a8d9e08680d518673bbccc096c" + "9eb232fed9d5eecc7edb09e09ed63884c666c8b9ff65b11fcccae817b993830b4766713250c175fd6d5ed5d18a8c6555583c9665a9e701" + "f0a55725824478bf3a3ec794fa2992afa2cce454c2c9a861afd9cd83dbb66e55aff4e4d5728a2b22a319b39c4df3a3cdeb8d71062d0215" + "12608805239e96d25562445fc30b894890dedc92c8d456029a2d382077956a0f4335c95b06758f2e245725b37c95da5ac1ec3ff4a70ae0" + "3f069a7a11e27ad124aefabc32947761", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_043_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" + "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "001122334455", + .keySize = HKS_RSA_KEY_SIZE_512, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_044_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000030000600000006000000060000000e010a0d37f6fc663a131cde4c27f458e46f9448c4ae99927d682a370a71ff936859b6f" + "50bab014de3c0fbdeb91aa01969be2b2ba1d11e60797e4b0bb9c1ffd09a56506e923f186b7aa593761bfe2d2fc7a09e6050dbe9bdf875d" + "684be2a76cc900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001bcb1642f1897f1f3" + "bf31291a682d344f5037e5615c490320c88675cb8e02e025e9386ff30574f9edf998ac313117818357810e80c32a6a122cf1d9163ba9d8" + "7e38f7291d3ecc39c5d13e94406de947c860de27ab10e90bccf42f76164ec03381", + .hexData = "00112233445566778899aabbccdd", + .keySize = HKS_RSA_KEY_SIZE_768, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_045_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000040000800000008000000080000000b4a4455910bcb2b65c2937ea25ae2bc5dff6df61644292c330c5985038fe6b3c485af0" + "7d963b10820242784a7c24d4c46038ae46f17ac854188cbc894982e9c00fac378dea8d6c6297e759362b3948b828d38e735daadf08acdc" + "dc0954eb32725084d74970cf6cb5c571cb16929adb414052fbe2d93cacc9e03d9e139685abe50000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "014107018fd65e9756de46584289ddf1140253b48632b9646baf9af201af02a747c424387e7d1e360b1715268869b8387f98c3ceb8eb24" + "f00895edd3d0f80d906760026ece80380d1b2719dd7cf6110fa8949bf22067f8f7d4072d355cb06b20271e25aba9b00730b3f1a549822d" + "a6628ca7118bb4d3d05bd1432fd072604cea01", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_046_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000080000000100000001000000010000c9354edd8b70a5f187bd3576b08cd52ef54468d027d061e45dca25e0526cc89b4bcbbe" + "1f70ee581a2834c9123b08cc28cfef131d7f8ae5ec5f22dd282cfafe922121da0bf578826a09c13cb5bb6500881a5f245d07ce87ccb670" + "0b5d91cab6d1d591b43558d62da7257c7d63accb6c1f804cc8772370d67d32c99911e33d0b62d186f068ec655c63759944fa8500722835" + "a5ffa35c0199ecac1a304a5ad5eb73cfe031711a3a4928157f9a9494a5c3f3b536be7d11763dd5af26e0ae3cb420d3fa3b6f587cf79faf" + "8ff31bf90304c554d1ab4b2db23a4f0c85a2cc793dc31c31ee21b436093900db2b6636e11bdb0f0fe9fff003d3a4486458027c13098eaf" + "99000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001100f583728bd1a11b842eaf4894d046b161a" + "9abf1a9e7061d8f69ca5560ee6c8367991b852bc437dfafd939b07e940da7516611136aff080386bc0f946f5d5c1f6310c856dd76b9969" + "23ea639b0c89c953498ace7e240704d8ff02793a7cd2b0d6fa254728cb17a3c2c33802efb4e0f176bd2a3710361e78a9c81b96a8eba36f" + "e0821a44f82e88e0028ce3aae7f17b295b53fba3b600a358a8321cf80274da7eec5778a2f11e6ec3fd2b110918e15c3a5da5832ef7651c" + "41a160d15679f4ea3bff56bd505f153e013e26a1475370606ddd05e36b76d7cde176eb62af1a48aae3237b86acb0a8c0ceee45a6ca1318" + "6b712e72116fb303775a0a4d8365bf4e35f1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_047_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "01000000000c0000800100008001000080010000c0d7a1b9eae690d22741b0bad5e6abdb786a201cbb01154f1364fd8b5fc23a09621bca" + "d8b997b32ad0120ee18c662a478313c3a5926151575944241e8ee464fa2fe60c79a324cbfef988275afb009c4aa05935da7a265cc415f7" + "212c9a6a92e2e6d75d621742ef8a2ca468aa5481560b8cd6d346b17f1960cafd2b815949f006613e9b0690c61b5ab83cb3ed746cda04e7" + "565f58a888136a631914c28f9f90851ae1653a9f1f2a60215833110e91ee6c226b97ae5d4ff104eecced33ffd916caa2a84877f58db389" + "3f8e846ee288a751863d867f80e7fc492f1d6da9aa0c60dc1774b343a899d2ea6688b81be72c12c3a79698ccb488c8a96342aa8ade6d15" + "46285d8e5fb35c41910584e9732c2756c40798f413331215814d283f6b7f67f3424f11d5da5cc4b63e163b23f9970c03bc24b924422536" + "021532590a5dbce0a0cff8e7052db4529e7b0205995d1bce29ab4f5ed9840985a57fd60144464c28f22a9bcc8f21b009a69b35f65f0343" + "5dd584b123167d6767226150656ac3c38917ab000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000001000187655eb9a881e5e0878b89c84472c6eb3b2a580d9406f8ad2292dfa9c1bc1eff8390bbe55a" + "b97624731e9ab025e17d81e438363fc3fcec1d86215fb2cce4f338edf47981d5d7fa1ab59cb0f5221295a997d7cb05f0898acc6a17af85" + "1f8e003fab903e92a67e6aacfb171c1dab637bc4744848e2f3b0a762dc62d0eeea800d348d86655640c3b76504c22a1a688a1cb120b3f6" + "11cb926eff5d40b8e0b9f27087e40da90375c16e013ca82e82a55634ae5ba46b4513631378412a44c923b38a59d5af20f66690f0d34813" + "ebafdae3968685390b9db7e8482573df5804b6191e0b32c85644f998de27cd58d6b0151a2645d5d309262c63f033000510528f4efeaa8f" + "ba78a85ba2b95d6ae78c2b29c26f0eb2485aacf275b0e7bd0cdf9992b3debcbabd3a7d74e9b50bc8d45223b668d61ff092276679de789b" + "397501599da8e34cdffc40f771929eaf49579d29a3f6bd03b27490aa195d4273ca3248af236ede466badaf076af2960585d997678417b6" + "d00c49460d173a5e5014712099829385d1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_048_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000cd7af64a4ce004dbfadb758f6d6c5fbc9640e00bc40e8ba08292c2a4c8b3b22d08c547" + "3eaa5083b4dd45bda9c5ce2c86789a7c2db787da6a3ae56736c18d025b6ef1b3a483cc25448de67956b94c390c03f44231939d9dff4985" + "e707dac520b00dcf18b6ae18e16c64f2f169945be2f98df16098e3e8ef3491cf310975a8e1a1e5ed96fc132d7e17ce84b9f4e6c2d842b0" + "739f515f0fe0d8c76ce7da95e4db26e048c3d7b911ef6489d66837f2f9fd8d1812a8417f611cdfd44c2bc5fa4f1f92a2eaee6a08d53189" + "91ad7d1d8e146210308bf456862fb691045443da3e2a92cc611ddb7a08f3f40803cfa3e6cf9abf8188fde526d5fc9c664f424dd5b17366" + "143718f2f6efffcbf42f495d1992db9728c38e993b43d4f191e48374b6c4e7116ecaaf63b5016207fa48407df7394b14a3744ab4a825d5" + "b9dede3e4d1271b2ffc2be70594f689a4695ca97609a3341bfb12e8386ad8deb5d9c95c6fad3f5448390ef5db2cd52a4d709276d6516f3" + "33611e9136d1f2de02927aa404f7c4d755dfe37d44ea9c8eb0a911ce25a7ae4fdd5dd38d1610295692f6ab7d7099913044ff7e348d25cc" + "cbe0e0e34e6fe5f4d1984b4070be9e5e855f58477fa49bf804f6b6136dfa60a8a318d11e031fddff42ec0b9f5243ab5bc3e771a17e3a5a" + "648f7d618d108a4b12d4bee7ae6a2ee43f9226e6878a3dd33ec2d3b981b0d22c7b1ea123f9000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100014b" + "4117668ad518b2802353e0dd906d57a227cc6642bd99018610bddc9fecbffaa255ae0c13503d8c45e5bedaa8a923c173f61038a618c933" + "52b2a5a4762a708c900b5161952b7512b06d924ee2ba39c25ec85c5dcfd450032928333ebb2eab140f5aa390741e84a0b030119e3b4993" + "cd15e12b219386c1e49cea26e9720011f2bb44d2a12b5ce3eb502567fd7b6e2cc9efd9c8a5828d4c29d88fd83243e77723bbccaa7d1d38" + "a65649ed0e6a3f40b34db35d51e5fb02d4125dac2ff3e802866babe322c20ece15c06e6bfd808f82838fae57f37aa4d660a4a7d33cae77" + "4a1c4d61dc0f7f983bd04a072b4ab9c39ac73c67b1a4f51e35d009e049463c572b0e5cfcac332a782608d39c7bd4c3be513aefa9bba8c2" + "2df88c40b3635d3e9dbbeaa4ced0e7f53a1599f8b9f3a164e7aa4954141bec6bd0a5052fccffab1ab53c941f9d04bab5eee41eeda05152" + "aad1ac2c39f8d1ad9fe3804dba684c981776ae1c9fc2dad2549708d158cf6350f0c4da940c69610decbfda5398580ea491424aabbd0f62" + "d14646fddd5509005d3474a506d6b919e133596422f60190b10b807b7992d57ae5dca530e30a064553e5cc22a8b98616b56425716eaac6" + "bd700a3e127011894493a86c2c483c04e6f22efb4049015cebd96bcaa36303b41cc7eabdd205efd99c1841c7f1cf6fddd27c167cadebba" + "d8989837da29f0e5c7f1047c222f79c9", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_FAILURE, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_INVALID_DIGEST, +#endif +}; +} // namespace + +class HksCryptoHalRsaOaepEncrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = HKS_KEY_BYTES(testCaseParams.keySize); + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + HksBlob tagAead = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_013 + * @tc.name : HksCryptoHalRsaOaepEncrypt_013 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_014 + * @tc.name : HksCryptoHalRsaOaepEncrypt_014 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_015 + * @tc.name : HksCryptoHalRsaOaepEncrypt_015 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_016 + * @tc.name : HksCryptoHalRsaOaepEncrypt_016 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_017 + * @tc.name : HksCryptoHalRsaOaepEncrypt_017 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_018 + * @tc.name : HksCryptoHalRsaOaepEncrypt_018 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_018, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_019 + * @tc.name : HksCryptoHalRsaOaepEncrypt_019 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_020 + * @tc.name : HksCryptoHalRsaOaepEncrypt_020 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_021 + * @tc.name : HksCryptoHalRsaOaepEncrypt_021 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_022 + * @tc.name : HksCryptoHalRsaOaepEncrypt_022 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_023 + * @tc.name : HksCryptoHalRsaOaepEncrypt_023 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_024 + * @tc.name : HksCryptoHalRsaOaepEncrypt_024 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_OAEP_ENCRYPT_024_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaOaepEncrypt_025 + * @tc.name : HksCryptoHalRsaOaepEncrypt_025 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-OAEP_SHA256 key failed:keysize +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_001_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_002_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_003_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_004_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_005_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_006_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_007_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_008_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_009_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_010_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_011_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_012_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_013_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_014_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_015_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_016_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_017_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_018_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_019_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_020_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_021_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_022_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_023_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_024_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_025_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_026_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_027_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_028_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_029_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_030_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_031_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_032_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_033_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_034_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_035_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_036_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_037_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_038_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_039_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_040_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalRsaPkcs1Sign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + + uint32_t dataLen = testCaseParams.hexData.length() / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &testCaseParams.usageSpec, &message, &signature), testCaseParams.signResult); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ( + HksCryptoHalVerify(&pubKey, &testCaseParams.usageSpec, &message, &signature), testCaseParams.verifyResult); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_001 + * @tc.name : HksCryptoHalRsaPkcs1Sign_001 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_002 + * @tc.name : HksCryptoHalRsaPkcs1Sign_002 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_003 + * @tc.name : HksCryptoHalRsaPkcs1Sign_003 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_004 + * @tc.name : HksCryptoHalRsaPkcs1Sign_004 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_005 + * @tc.name : HksCryptoHalRsaPkcs1Sign_005 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_006 + * @tc.name : HksCryptoHalRsaPkcs1Sign_006 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_007 + * @tc.name : HksCryptoHalRsaPkcs1Sign_007 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_008 + * @tc.name : HksCryptoHalRsaPkcs1Sign_008 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_009 + * @tc.name : HksCryptoHalRsaPkcs1Sign_009 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_010 + * @tc.name : HksCryptoHalRsaPkcs1Sign_010 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_011 + * @tc.name : HksCryptoHalRsaPkcs1Sign_011 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_012 + * @tc.name : HksCryptoHalRsaPkcs1Sign_012 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_013 + * @tc.name : HksCryptoHalRsaPkcs1Sign_013 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_014 + * @tc.name : HksCryptoHalRsaPkcs1Sign_014 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_015 + * @tc.name : HksCryptoHalRsaPkcs1Sign_015 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_016 + * @tc.name : HksCryptoHalRsaPkcs1Sign_016 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_017 + * @tc.name : HksCryptoHalRsaPkcs1Sign_017 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_018 + * @tc.name : HksCryptoHalRsaPkcs1Sign_018 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_018, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_019 + * @tc.name : HksCryptoHalRsaPkcs1Sign_019 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_020 + * @tc.name : HksCryptoHalRsaPkcs1Sign_020 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_021 + * @tc.name : HksCryptoHalRsaPkcs1Sign_021 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_022 + * @tc.name : HksCryptoHalRsaPkcs1Sign_022 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_023 + * @tc.name : HksCryptoHalRsaPkcs1Sign_023 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_024 + * @tc.name : HksCryptoHalRsaPkcs1Sign_024 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_024_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_025 + * @tc.name : HksCryptoHalRsaPkcs1Sign_025 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_025, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_025_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_026 + * @tc.name : HksCryptoHalRsaPkcs1Sign_026 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_026, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_026_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_027 + * @tc.name : HksCryptoHalRsaPkcs1Sign_027 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_027, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_027_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_028 + * @tc.name : HksCryptoHalRsaPkcs1Sign_028 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_028, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_028_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_029 + * @tc.name : HksCryptoHalRsaPkcs1Sign_029 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_029, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_029_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_030 + * @tc.name : HksCryptoHalRsaPkcs1Sign_030 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_030, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_030_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_031 + * @tc.name : HksCryptoHalRsaPkcs1Sign_031 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_031, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_031_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_032 + * @tc.name : HksCryptoHalRsaPkcs1Sign_032 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_032, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_032_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_033 + * @tc.name : HksCryptoHalRsaPkcs1Sign_033 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_033, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_033_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_034 + * @tc.name : HksCryptoHalRsaPkcs1Sign_034 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_034, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_034_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_035 + * @tc.name : HksCryptoHalRsaPkcs1Sign_035 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_035, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_035_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_036 + * @tc.name : HksCryptoHalRsaPkcs1Sign_036 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_036, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_036_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_037 + * @tc.name : HksCryptoHalRsaPkcs1Sign_037 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_037, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_037_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_038 + * @tc.name : HksCryptoHalRsaPkcs1Sign_038 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_038, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_038_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_039 + * @tc.name : HksCryptoHalRsaPkcs1Sign_039 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_039, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_039_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_040 + * @tc.name : HksCryptoHalRsaPkcs1Sign_040 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_040, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PKCS1_SIGN_040_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp new file mode 100755 index 0000000000000000000000000000000000000000..97255448aaa96b24473ff50a04f7ab5d4e540fa9 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp @@ -0,0 +1,955 @@ +/* + * Copyright (c) 2021 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 "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { +namespace { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_001_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_002_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_003_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_004_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_005_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_006_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_007_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_008_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_009_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_010_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_011_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_012_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_013_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_014_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_015_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_016_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_017_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_018_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_019_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +#if defined(_USE_OPENSSL_) + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_020_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_021_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_022_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_023_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_024_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_025_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#endif +#if defined(_USE_OPENSSL_) + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_026_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_027_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_028_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_PSS_SIGN_029_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, + .hexData = "00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalRsaPssSign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + + uint32_t dataLen = testCaseParams.hexData.length() / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &testCaseParams.usageSpec, &message, &signature), testCaseParams.signResult); + + if (testCaseParams.signResult == HKS_SUCCESS) { + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &testCaseParams.usageSpec, &message, &signature), + testCaseParams.verifyResult); + HksFree(pubKey.data); + } + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); + } +}; + +/** + * @tc.number : HksCryptoHalRsaPssSign_001 + * @tc.name : HksCryptoHalRsaPssSign_001 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_002 + * @tc.name : HksCryptoHalRsaPssSign_002 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_003 + * @tc.name : HksCryptoHalRsaPssSign_003 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_004 + * @tc.name : HksCryptoHalRsaPssSign_004 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_005 + * @tc.name : HksCryptoHalRsaPssSign_005 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_005_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_006 + * @tc.name : HksCryptoHalRsaPssSign_006 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_006_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_007 + * @tc.name : HksCryptoHalRsaPssSign_007 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_008 + * @tc.name : HksCryptoHalRsaPssSign_008 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_009 + * @tc.name : HksCryptoHalRsaPssSign_009 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_010 + * @tc.name : HksCryptoHalRsaPssSign_010 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_011 + * @tc.name : HksCryptoHalRsaPssSign_011 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_012 + * @tc.name : HksCryptoHalRsaPssSign_012 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_012_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_013 + * @tc.name : HksCryptoHalRsaPssSign_013 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_013_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_014 + * @tc.name : HksCryptoHalRsaPssSign_014 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_014_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_015 + * @tc.name : HksCryptoHalRsaPssSign_015 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_016 + * @tc.name : HksCryptoHalRsaPssSign_016 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_016_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_017 + * @tc.name : HksCryptoHalRsaPssSign_017 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_018 + * @tc.name : HksCryptoHalRsaPssSign_018 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_018, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_018_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_019 + * @tc.name : HksCryptoHalRsaPssSign_019 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_019_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_020 + * @tc.name : HksCryptoHalRsaPssSign_020 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_020_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_021 + * @tc.name : HksCryptoHalRsaPssSign_021 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_021_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_022 + * @tc.name : HksCryptoHalRsaPssSign_022 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_022_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_023 + * @tc.name : HksCryptoHalRsaPssSign_023 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_023_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_024 + * @tc.name : HksCryptoHalRsaPssSign_024 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_024_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_025 + * @tc.name : HksCryptoHalRsaPssSign_025 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_025, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_025_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_026 + * @tc.name : HksCryptoHalRsaPssSign_026 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_026, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_026_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_027 + * @tc.name : HksCryptoHalRsaPssSign_027 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_027, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_027_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_028 + * @tc.name : HksCryptoHalRsaPssSign_028 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_028, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_028_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_029 + * @tc.name : HksCryptoHalRsaPssSign_029 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_029, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_PSS_SIGN_029_PARAMS); +} +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/os_dependency/BUILD.gn b/frameworks/huks_standard/main/os_dependency/BUILD.gn index 3524e363b5cec49f49f87b65e01b0c96965daa3f..aeacea8141070bd219a482c435fd005e5a1a8c1d 100644 --- a/frameworks/huks_standard/main/os_dependency/BUILD.gn +++ b/frameworks/huks_standard/main/os_dependency/BUILD.gn @@ -50,7 +50,7 @@ ohos_static_library("libhuks_os_dependency_standard_static") { external_deps = [ "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] cflags_cc = [ "-DHILOG_ENABLE" ] cflags = [ "-DHILOG_ENABLE" ] diff --git a/huks.gni b/huks.gni new file mode 100755 index 0000000000000000000000000000000000000000..82340fbeb4a3414d5b773f4d286ac071503a1cdc --- /dev/null +++ b/huks.gni @@ -0,0 +1,15 @@ +# Copyright (c) 2021 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. + +use_crypto_lib = "openssl" +non_rwlock_support = false diff --git a/interfaces/innerkits/huks_standard/main/include/hks_api.h b/interfaces/innerkits/huks_standard/main/include/hks_api.h index a9bf6f5069bfba7c4c650700d1829f43186fb8ba..288ccf8604058c2c60eb962ee2e3c470781b9f63 100755 --- a/interfaces/innerkits/huks_standard/main/include/hks_api.h +++ b/interfaces/innerkits/huks_standard/main/include/hks_api.h @@ -88,6 +88,8 @@ HKS_API_EXPORT int32_t HksUnwrapKey(const struct HksBlob *keyAlias, const struct HKS_API_EXPORT int32_t HksBnExpMod(struct HksBlob *x, const struct HksBlob *a, const struct HksBlob *e, const struct HksBlob *n); +HKS_API_EXPORT int32_t HcmIsDeviceKeyExist(const struct HksParamSet *paramSet); + #ifdef __cplusplus } #endif diff --git a/interfaces/innerkits/huks_standard/main/include/hks_type.h b/interfaces/innerkits/huks_standard/main/include/hks_type.h index dfb1d58a1a0d0d744df7f975db1464ece55db601..c173732bddb958e4c93fadc88c91b34ab2b69704 100755 --- a/interfaces/innerkits/huks_standard/main/include/hks_type.h +++ b/interfaces/innerkits/huks_standard/main/include/hks_type.h @@ -51,7 +51,7 @@ extern "C" { #define HKS_MAX_KEY_ALIAS_LEN 64 #define HKS_MAX_PROCESS_NAME_LEN 50 #define HKS_MAX_RANDOM_LEN 1024 -#define HKS_KEY_BYTES(keySize) ((keySize) / HKS_BITS_PER_BYTE) +#define HKS_KEY_BYTES(keySize) (((keySize) + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE) #define HKS_SIGNATURE_MIN_SIZE 64 #define HKS_ARRAY_SIZE(arr) ((sizeof(arr)) / (sizeof((arr)[0]))) #define MAX_OUT_BLOB_SIZE (5 * 1024 * 1024) @@ -90,6 +90,7 @@ enum HksKeyPurpose { HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ }; enum HksKeyDigest { @@ -121,11 +122,14 @@ enum HksCipherMode { }; enum HksKeySize { + HKS_RSA_KEY_SIZE_512 = 512, + HKS_RSA_KEY_SIZE_768 = 768, HKS_RSA_KEY_SIZE_1024 = 1024, HKS_RSA_KEY_SIZE_2048 = 2048, HKS_RSA_KEY_SIZE_3072 = 3072, HKS_RSA_KEY_SIZE_4096 = 4096, + HKS_ECC_KEY_SIZE_224 = 224, HKS_ECC_KEY_SIZE_256 = 256, HKS_ECC_KEY_SIZE_384 = 384, HKS_ECC_KEY_SIZE_521 = 521, @@ -136,11 +140,16 @@ enum HksKeySize { HKS_AES_KEY_SIZE_512 = 512, HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, }; enum HksKeyAlg { HKS_ALG_RSA = 1, HKS_ALG_ECC = 2, + HKS_ALG_DSA = 3, HKS_ALG_AES = 20, HKS_ALG_HMAC = 50, @@ -150,6 +159,7 @@ enum HksKeyAlg { HKS_ALG_ECDH = 100, HKS_ALG_X25519 = 101, HKS_ALG_ED25519 = 102, + HKS_ALG_DH = 103, }; enum HksKeyGenerateType { diff --git a/interfaces/innerkits/huks_standard/main/src/hks_api.c b/interfaces/innerkits/huks_standard/main/src/hks_api.c index 649596e90dfc27a94807f7f933051aa703c97a9c..08a46958a1883b5887b9ddf55d15199ebb60eeb0 100755 --- a/interfaces/innerkits/huks_standard/main/src/hks_api.c +++ b/interfaces/innerkits/huks_standard/main/src/hks_api.c @@ -235,9 +235,14 @@ HKS_API_EXPORT int32_t HksSign(const struct HksBlob *key, const struct HksParamS if ((key == NULL) || (paramSet == NULL) || (srcData == NULL) || (signature == NULL)) { return HKS_ERROR_NULL_POINTER; } - int32_t ret = HksClientSign(key, paramSet, srcData, signature); - HKS_LOG_I("leave sign, result = %d", ret); - return ret; + + struct HksParam *isKeyAlias = NULL; + int32_t ret = HksGetParam(paramSet, HKS_TAG_IS_KEY_ALIAS, &isKeyAlias); + if ((ret == HKS_SUCCESS) && (!isKeyAlias->boolParam)) { + return HksLocalSign(key, paramSet, srcData, signature); + } + + return HksClientSign(key, paramSet, srcData, signature); #else (void)key; (void)paramSet; @@ -568,3 +573,10 @@ HKS_API_EXPORT int32_t HksBnExpMod(struct HksBlob *x, const struct HksBlob *a, return HKS_ERROR_NOT_SUPPORTED; #endif } + +HKS_API_EXPORT int32_t HcmIsDeviceKeyExist(const struct HksParamSet *paramSet) +{ + (void)paramSet; + return HKS_ERROR_NOT_SUPPORTED; +} + diff --git a/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn b/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..69eded2cd2bbd62c0b5f01a7c81a31eaa4c46c1d --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn @@ -0,0 +1,84 @@ +# Copyright (C) 2021 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. + +import("//base/security/huks/huks.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_moduletest("huks_mt_test") { + module_out_path = module_output_path + sources = [ + "src/hks_aes_cipher_mt.cpp", + "src/hks_aes_decrypt_mt.cpp", + "src/hks_aes_encrypt_mt.cpp", + "src/hks_aes_key_mt.cpp", + "src/hks_agree_mt.cpp", + "src/hks_dsa_mt.cpp", + "src/hks_ecc_key_mt.cpp", + "src/hks_ecc_sign_mt.cpp", + "src/hks_ecc_verify_mt.cpp", + "src/hks_hmac_mt.cpp", + "src/hks_rsa_common_mt.cpp", + "src/hks_rsa_ecb_nopadding_mt.cpp", + "src/hks_rsa_ecb_oaep_padding_mt.cpp", + "src/hks_rsa_ecb_oaep_sha1_mt.cpp", + "src/hks_rsa_ecb_oaep_sha224_mt.cpp", + "src/hks_rsa_ecb_oaep_sha256_mt.cpp", + "src/hks_rsa_ecb_oaep_sha384_mt.cpp", + "src/hks_rsa_ecb_oaep_sha512_mt.cpp", + "src/hks_rsa_ecb_pkcs1_padding_mt.cpp", + "src/hks_rsa_md5_with_rsa_mt.cpp", + "src/hks_rsa_none_with_rsa_mt.cpp", + "src/hks_rsa_sha1_with_rsa_mt.cpp", + "src/hks_rsa_sha1_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha224_with_rsa_mt.cpp", + "src/hks_rsa_sha224_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha256_with_rsa_mt.cpp", + "src/hks_rsa_sha256_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha384_with_rsa_mt.cpp", + "src/hks_rsa_sha384_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha512_with_rsa_mt.cpp", + "src/hks_rsa_sha512_with_rsa_pss_mt.cpp", + "src/openssl_aes_helper.c", + "src/openssl_dh_helper.c", + "src/openssl_dsa_helper.c", + "src/openssl_ecc_helper.c", + "src/openssl_hmac_helper.c", + "src/openssl_rsa_helper.c", + ] + + if (use_crypto_lib == "openssl") { + defines = [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines = [ "_USE_MBEDTLS_" ] + } + + include_dirs = [ + "//utils/native/base/include", + "//third_party/bounds_checking_function/include", + "//third_party/openssl/include/", + "../unittest/include", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "include", + ] + deps = [ + "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", + "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", + "//third_party/bounds_checking_function:libsec_static", + "//third_party/googletest:gtest_main", + "//third_party/openssl:libcrypto_static", + "//utils/native/base:utils", + ] +} diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_rsa_common_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_rsa_common_mt.h new file mode 100755 index 0000000000000000000000000000000000000000..e3b659284345a0c558c1b319350312caeb82f7f9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_rsa_common_mt.h @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef HKS_RSA_COMMON_MT_H +#define HKS_RSA_COMMON_MT_H + +#include +#include + +#include "hks_type.h" +#include "hks_param.h" + +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +#define BIT_NUM_OF_UINT8 8 + +struct GenerateKeyCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct EncryptLocalCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct EncryptServiceCaseParams { + std::string alias; + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + uint32_t keySize; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct DecryptLocalCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct DecryptServiceCaseParams { + std::string alias; + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct SignLocalCaseParams { + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct SignServiceCaseParams { + std::string alias; + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct VerifyLocalCaseParams { + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct VerifyServiceCaseParams { + std::string alias; + std::vector params; + int padding; + HksKeyDigest keyDigest; + uint32_t keySize; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +class HksRsaCommonMt { +protected: + void GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams); + + void EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams); + + void EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams); + + void DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams); + + void DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams); + + void SignLocalTestCase(const SignLocalCaseParams &testCaseParams); + + void SignServiceTestCase(const SignServiceCaseParams &testCaseParams); + + void VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams); + + void VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams); +}; +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS +#endif \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..5fadd20d11191419ed5402b92c55f89f235d341c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h @@ -0,0 +1,56 @@ + +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_AES_HELPER_H +#define OPENSSL_AES_HELPER_H + +#include + +#include "hks_param.h" +#include "hks_type.h" +#include "openssl/rand.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define AAD_SIZE 16 +#define COMPLEMENT_LEN 16 +#define IV_SIZE 16 +#define OUT_PARAMSET_SIZE 2048 +#define AUTHID_KEY_SIZE 256 + +int32_t GenerateAesKey(const int key_len, struct HksBlob *randomKey); + +int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey); + +int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey); + +int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey, const struct HksBlob *tagAead); + +int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey, const struct HksBlob *tagDec); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..02ffc3f5dacadaae8b9863b85440d19266b76aa9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_DH_HELPER_H +#define OPENSSL_DH_HELPER_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DH_FAILED 1 +#define DH_SUCCESS 0 + +int32_t DhGenerateKey(const int keyLen, struct HksBlob *key); + +int32_t DhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey); + +int32_t DhGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); + +int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..2de29fe3da01a3371457102b6461d92aacfbb8db --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_DSA_SIGN_MT_HELPER_H +#define OPENSSL_DSA_SIGN_MT_HELPER_H + +#include + +#include +#include + +#include "hks_type.h" +#include "hks_param.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define BIT_NUM_OF_UINT8 8 +#define DSA_FAILED 1 +#define DSA_SUCCESS 0 + +EVP_PKEY *GenerateDsaKey(const uint32_t keySize); + +void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key); + +int32_t OpensslSignDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType); + +int32_t OpensslVerifyDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType); + +int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..9f5c871a52c43246ad45b71bf5262bfbe9f396c8 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_ECC_HELPER_H +#define OPENSSL_ECC_HELPER_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ECC_KEYPAIR_CNT 3 +#define ECC_FAILED 1 +#define ECC_SUCCESS 0 +#define ECC_KEY_SIZE 528 +#define ECC_MESSAGE_SIZE 141 + +int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key); + +int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *message, struct HksBlob *signature); + +int32_t EcdsaVerify( + const struct HksBlob *key, int digest, const struct HksBlob *message, const struct HksBlob *signature); + +int32_t GetEccPubKey(const struct HksBlob *input, struct HksBlob *output); + +int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key); + +int32_t EcdhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..f5b8df3cd911fdc866be7da45390d19a0b05d294 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_HMAC_HELPER_H +#define OPENSSL_HMAC_HELPER_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define BIT_NUM_OF_UINT8 8 +#define HMAC_KEY_SIZE 512 +#define HMAC_MESSAGE_SIZE 64 +#define HMAC_FAILED 1 +#define HMAC_SUCCESS 0 +#define OUT_PARAMSET_SIZE 2048 + +int32_t HmacGenerateKey(int key_len, struct HksBlob *key); + +int32_t HmacHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h new file mode 100755 index 0000000000000000000000000000000000000000..a9a341c34b16f9b96dedaa67aa663c6ace22fa20 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2021 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. + */ + +#ifndef OPENSSL_RSA_MT_HELPER_H +#define OPENSSL_RSA_MT_HELPER_H + +#include + +#include +#include + +#include "hks_type.h" +#include "hks_param.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define BIT_NUM_OF_UINT8 8 +#define RSA_FAILED (-1) +#define RSA_SUCCESS 0 + +void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key); + +EVP_PKEY *GenerateRSAKey(const uint32_t keySize); + +void OpensslGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key); + +int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + +int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + +int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + +int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..9092b21e2daf145b086ee8ddbfeb64315fb4e8e9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp @@ -0,0 +1,662 @@ +/* + * Copyright (C) 2021 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 "openssl_aes_helper.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; +const char TEST_AES_KEY[] = "This is a AES key"; + +const TestCaseParams HUKS_AES_CIPER_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesCipherMt : public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult); + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + HksFree(plainTextDecrypt.data); + } + + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00100 + * @tc.name : HksAesCipherMt00100 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00200 + * @tc.name : HksAesCipherMt00200 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00300 + * @tc.name : HksAesCipherMt00300 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00400 + * @tc.name : HksAesCipherMt00400 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00500 + * @tc.name : HksAesCipherMt00500 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00600 + * @tc.name : HksAesCipherMt00600 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00700 + * @tc.name : HksAesCipherMt00700 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00800 + * @tc.name : HksAesCipherMt00800 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00900 + * @tc.name : HksAesCipherMt00900 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01000 + * @tc.name : HksAesCipherMt01000 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01100 + * @tc.name : HksAesCipherMt01100 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01200 + * @tc.name : HksAesCipherMt01200 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01300 + * @tc.name : HksAesCipherMt01300 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01400 + * @tc.name : HksAesCipherMt01400 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01500 + * @tc.name : HksAesCipherMt01500 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01500_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01600 + * @tc.name : HksAesCipherMt01600 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01700 + * @tc.name : HksAesCipherMt01700 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01800 + * @tc.name : HksAesCipherMt01800 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..1959e40cfaa6f6727fc0c7a7a5a03f63b0e6aaf1 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp @@ -0,0 +1,686 @@ +/* + * Copyright (C) 2021 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 "openssl_aes_helper.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesDecryptMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + EXPECT_EQ( + AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), testCaseParams.encryptResult); + cipherText.size += AAD_SIZE; + (void)memcpy_s(cipherText.data + AAD_SIZE, AAD_SIZE, tagAead.data, AAD_SIZE); + HksFree(tagAead.data); + } else { + EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), testCaseParams.encryptResult); + } + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult); + if (testCaseParams.decryptResult != HKS_ERROR_NOT_SUPPORTED) { + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + } + + HksFree(authId.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00100 + * @tc.name : HksAesDecryptMt00100 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00200 + * @tc.name : HksAesDecryptMt00200 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00300 + * @tc.name : HksAesDecryptMt00300 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00400 + * @tc.name : HksAesDecryptMt00400 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00500 + * @tc.name : HksAesDecryptMt00500 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00600 + * @tc.name : HksAesDecryptMt00600 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00700 + * @tc.name : HksAesDecryptMt00700 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00800 + * @tc.name : HksAesDecryptMt00800 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00900 + * @tc.name : HksAesDecryptMt00900 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01000 + * @tc.name : HksAesDecryptMt01000 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01100 + * @tc.name : HksAesDecryptMt01100 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01200 + * @tc.name : HksAesDecryptMt01200 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01300 + * @tc.name : HksAesDecryptMt01300 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01400 + * @tc.name : HksAesDecryptMt01400 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01500 + * @tc.name : HksAesDecryptMt01500 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01500_PARAMS); +} +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01600 + * @tc.name : HksAesDecryptMt01600 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01700 + * @tc.name : HksAesDecryptMt01700 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01800 + * @tc.name : HksAesDecryptMt01800 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ebf8816076e7526db713726501abe42255b5fc44 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp @@ -0,0 +1,682 @@ +/* + * Copyright (C) 2021 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 "openssl_aes_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesEncryptMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + (void)memcpy_s(tagAead.data, AAD_SIZE, cipherText.data + AAD_SIZE, AAD_SIZE); + cipherText.size = AAD_SIZE; + EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead), + testCaseParams.decryptResult); + HksFree(tagAead.data); + } else { + EXPECT_EQ( + AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), testCaseParams.decryptResult); + } + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + } + + HksFree(authId.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00100 + * @tc.name : HksAesEncryptMt00100 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00200 + * @tc.name : HksAesEncryptMt00200 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00300 + * @tc.name : HksAesEncryptMt00300 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00400 + * @tc.name : HksAesEncryptMt00400 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00500 + * @tc.name : HksAesEncryptMt00500 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00600 + * @tc.name : HksAesEncryptMt00600 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00700 + * @tc.name : HksAesEncryptMt00700 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00800 + * @tc.name : HksAesEncryptMt00800 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00900 + * @tc.name : HksAesEncryptMt00900 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01000 + * @tc.name : HksAesEncryptMt01000 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01100 + * @tc.name : HksAesEncryptMt01100 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01200 + * @tc.name : HksAesEncryptMt01200 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01300 + * @tc.name : HksAesEncryptMt01300 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01400 + * @tc.name : HksAesEncryptMt01400 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01500 + * @tc.name : HksAesEncryptMt01500 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01500_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01600 + * @tc.name : HksAesEncryptMt01600 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01700 + * @tc.name : HksAesEncryptMt01700 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01800 + * @tc.name : HksAesEncryptMt01800 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d37089082e9c813a917b3be6bb12d77da3d0ca91 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp @@ -0,0 +1,678 @@ +/* + * Copyright (C) 2021 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 "openssl_aes_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; +const char TEST_AES_KEY[] = "This is a AES key"; + +const TestCaseParams HUKS_AES_KEY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesKeyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(OUT_PARAMSET_SIZE); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); + paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + + HksParam *symmetricParam = NULL; + HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); + HksBlob symmetricKey = { .size = symmetricParam->blob.size, + .data = (uint8_t *)HksMalloc(symmetricParam->blob.size) }; + (void)memcpy_s( + symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), + testCaseParams.encryptResult); + EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), + testCaseParams.decryptResult); + HksFree(tagAead.data); + } else { + EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), testCaseParams.encryptResult); + EXPECT_EQ( + AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), testCaseParams.decryptResult); + } + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + + HksFree(paramSetOut); + HksFree(symmetricKey.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00100 + * @tc.name : HksAesKeyMt00100 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00200 + * @tc.name : HksAesKeyMt00200 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00300 + * @tc.name : HksAesKeyMt00300 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00400 + * @tc.name : HksAesKeyMt00400 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00500 + * @tc.name : HksAesKeyMt00500 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00600 + * @tc.name : HksAesKeyMt00600 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00700 + * @tc.name : HksAesKeyMt00700 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00800 + * @tc.name : HksAesKeyMt00800 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00900 + * @tc.name : HksAesKeyMt00900 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01000 + * @tc.name : HksAesKeyMt01000 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01100 + * @tc.name : HksAesKeyMt01100 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01200 + * @tc.name : HksAesKeyMt01200 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01300 + * @tc.name : HksAesKeyMt01300 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01400 + * @tc.name : HksAesKeyMt01400 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01500 + * @tc.name : HksAesKeyMt01500 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01500_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01600 + * @tc.name : HksAesKeyMt01600 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01700 + * @tc.name : HksAesKeyMt01700 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01800 + * @tc.name : HksAesKeyMt01800 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..112113db089f994f94c3b92dea9c110bce0752ed --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp @@ -0,0 +1,908 @@ +/* + * Copyright (C) 2021 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 "openssl_ecc_helper.h" +#include "openssl_dh_helper.h" + +#include + +#include "hks_api.h" +#include "hks_config.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector generateKeyParams; + std::vector agreeKeyParams; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const char ALISE_KEY[] = "This is a alise key"; +const char BOB_KEY[] = "This is a bob key"; +const uint32_t KEY_MEMORY = 4096; + +int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, + struct HksBlob *priKey, struct HksBlob *pubKey) +{ + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + if (keyLen == 0) { + return HKS_FAILURE; + } + + uint8_t *localData = (uint8_t *)HksMalloc(keyLen); + if (localData == NULL) { + return HKS_FAILURE; + } + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = { .size = keyLen, .data = localData } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { + return HKS_FAILURE; + } + + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + priKey->size = priParam->blob.size; + (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + pubKey->size = pubParam->blob.size; + (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); + + HksFree(localData); + HksFreeParamSet(¶mOutSet); + return HKS_SUCCESS; +} + +const TestCaseParams HUKS_AGREE_MT_00100_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00200_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00300_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00400_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00500_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00600_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00700_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00800_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00900_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01000_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01100_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01200_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +#ifdef HKS_SUPPORT_DH_C +const TestCaseParams HUKS_AGREE_MT_01300_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01400_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01500_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01600_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01700_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01800_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01900_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_02000_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_02100_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +#endif +} // namespace + +class HksAgreeMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void ServiceAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams, + struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob) + { + struct HksParamSet *agreeKeyParams = NULL; + HksInitParamSet(&agreeKeyParams); + HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(&agreeKeyParams); +#ifdef HKS_SUPPORT_DH_C + uint32_t algorithm = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_ALGORITHM); +#endif + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + EXPECT_EQ(HksGenerateKey(&bob, generateKeyParams, NULL), testCaseParams.generateKeyResult); + + HksBlob x509KeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob x509KeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(HksExportPublicKey(&bob, generateKeyParams, &x509KeyBob), HKS_SUCCESS); +#ifdef HKS_SUPPORT_DH_C + if (algorithm == HKS_ALG_ECDH) { +#endif + EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); +#ifdef HKS_SUPPORT_DH_C + } else if (algorithm == HKS_ALG_DH) { + EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); + EXPECT_EQ(DhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); + } +#endif + + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &x509KeyAlise, agreeKeyBob), testCaseParams.agreeResult); + + HksFree(alise.data); + HksFree(x509KeyAlise.data); + HksFree(x509KeyBob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFreeParamSet(&agreeKeyParams); + } + + void LocalAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams, + struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob, int32_t scenario) + { + struct HksParamSet *agreeKeyParams = NULL; + HksInitParamSet(&agreeKeyParams); + HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(&agreeKeyParams); + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + if (scenario == 0) { + struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(LocalHksGenerate(keySize, &alise, generateKeyParams, &priKeyAlise, &pubKeyAlise), + testCaseParams.generateKeyResult); + EXPECT_EQ(LocalHksGenerate(keySize, &bob, generateKeyParams, &priKeyBob, &pubKeyBob), + testCaseParams.generateKeyResult); + EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult); + HksFree(priKeyAlise.data); + HksFree(priKeyBob.data); + } else if (scenario == 1) { + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(ECCGenerateKey(keySize, &bob), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult); + HksFree(alise.data); + HksFree(bob.data); + } + HksFreeParamSet(&agreeKeyParams); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + } + + void EcdhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksParamSet *generateKeyParams = NULL; + HksInitParamSet(&generateKeyParams); + HksAddParams( + generateKeyParams, testCaseParams.generateKeyParams.data(), testCaseParams.generateKeyParams.size()); + HksBuildParamSet(&generateKeyParams); + + uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + if (storage == HKS_STORAGE_TEMP) { + LocalAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob, scenario); + } else if (storage == HKS_STORAGE_PERSISTENT) { + ServiceAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob); + } + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(&generateKeyParams); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } + +#ifdef HKS_SUPPORT_DH_C + void DhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + if (storage == HKS_STORAGE_TEMP) { + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + if (scenario == 0) { + struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(LocalHksGenerate(keySize, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), + testCaseParams.generateKeyResult); + EXPECT_EQ(LocalHksGenerate(keySize, &bob, paramInSet, &priKeyBob, &pubKeyBob), + testCaseParams.generateKeyResult); + EXPECT_EQ(DhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(DhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult); + HksFree(priKeyAlise.data); + HksFree(priKeyBob.data); + } else if (scenario == 1) { + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(DhGenerateKey(keySize, &bob), testCaseParams.generateKeyResult); + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult); + HksFree(alise.data); + HksFree(bob.data); + } + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + } else if (storage == HKS_STORAGE_PERSISTENT) { + ServiceAgreeScenario(testCaseParams, paramInSet, &agreeKeyAlise, &agreeKeyBob); + } + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +#endif +}; + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00100 + * @tc.name : HksAgreeMt00100 + * @tc.desc : Both parties use huks to generate an ecc224 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00100, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00100_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00200 + * @tc.name : HksAgreeMt00200 + * @tc.desc : Both parties use huks to generate an ecc256 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00200, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00200_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00300 + * @tc.name : HksAgreeMt00300 + * @tc.desc : Both parties use huks to generate an ecc384 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00300, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00300_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00400 + * @tc.name : HksAgreeMt00400 + * @tc.desc : Both parties use huks to generate an ecc521 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00400, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00400_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00500 + * @tc.name : HksAgreeMt00500 + * @tc.desc : Both parties use OpenSSL to generate an ecc224 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00500, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00500_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00600 + * @tc.name : HksAgreeMt00600 + * @tc.desc : Both parties use OpenSSL to generate an ecc256 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00600, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00600_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00700 + * @tc.name : HksAgreeMt00700 + * @tc.desc : Both parties use OpenSSL to generate an ecc384 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00700, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00700_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00800 + * @tc.name : HksAgreeMt00800 + * @tc.desc : Both parties use OpenSSL to generate an ecc521 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00800, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00800_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00900 + * @tc.name : HksAgreeMt00900 + * @tc.desc : One party uses the key of ECC224 for openssl negotiation, and the other party uses the key of ECC224 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00900, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00900_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01000 + * @tc.name : HksAgreeMt01000 + * @tc.desc : One party uses the key of ECC256 for openssl negotiation, and the other party uses the key of ECC256 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01000, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01000_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01100 + * @tc.name : HksAgreeMt01100 + * @tc.desc : One party uses the key of ECC384 for openssl negotiation, and the other party uses the key of ECC384 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01100, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01100_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01200 + * @tc.name : HksAgreeMt01200 + * @tc.desc : One party uses the key of ECC521 for openssl negotiation, and the other party uses the key of ECC521 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01200, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01200_PARAMS, 0); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksAgreeMt.HksAgreeMt01300 + * @tc.name : HksAgreeMt01300 + * @tc.desc : Both parties use huks to generate an dh2048 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01300, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01300_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01400 + * @tc.name : HksAgreeMt01400 + * @tc.desc : Both parties use huks to generate an dh3072 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01400, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01400_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01500 + * @tc.name : HksAgreeMt01500 + * @tc.desc : Both parties use huks to generate an dh4096 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01500, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01500_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01600 + * @tc.name : HksAgreeMt01600 + * @tc.desc : Both parties use OpenSSL to generate an dh2048 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01600, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01600_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01700 + * @tc.name : HksAgreeMt01700 + * @tc.desc : Both parties use OpenSSL to generate an dh3072 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01700, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01700_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01800 + * @tc.name : HksAgreeMt01800 + * @tc.desc : Both parties use OpenSSL to generate an dh4096 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01800, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01800_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01900 + * @tc.name : HksAgreeMt01900 + * @tc.desc : One party uses the key of dh2048 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01900, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01900_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt02000 + * @tc.name : HksAgreeMt02000 + * @tc.desc : One party uses the key of dh3072 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt02000, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_02000_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt02100 + * @tc.name : HksAgreeMt02100 + * @tc.desc : One party uses the key of dh4096 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt02100, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_02100_PARAMS, 0); +} +#endif +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..4ec0c1482f55ea1cb5ac7908db34fd232e9c3101 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp @@ -0,0 +1,1137 @@ +/* + * Copyright (C) 2021 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 "openssl_dsa_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for DSA"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_1024 = 1024; + +struct TestCaseParams { + std::vector params; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_DSA_MT_00100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00800_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01000_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB } }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01800_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02000_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; +} // namespace + +class HksDsaMt : public testing::Test { +protected: + void GenerateKeyTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void SignLocalTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void SignServiceTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void VerifyLocalTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void VerifyServiceTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + + EVP_PKEY_free(pkey); + HksFree(signData.data); + HksFree(x509Key.data); + HksFree(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksDsaMT00100 + * @tc.name : HksDsaMT00100 + * @tc.desc : Test huks generate key (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_00100_PARAMS); +} + +/** + * @tc.number : HksDsaMT00200 + * @tc.name : HksDsaMT00200 + * @tc.desc : Test huks sign (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_00200_PARAMS); +} + +/** + * @tc.number : HksDsaMT00300 + * @tc.name : HksDsaMT00300 + * @tc.desc : Test huks sign (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_00300_PARAMS); +} + +/** + * @tc.number : HksDsaMT00400 + * @tc.name : HksDsaMT00400 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_00400_PARAMS); +} + +/** + * @tc.number : HksDsaMT00500 + * @tc.name : HksDsaMT00500 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_00500_PARAMS); +} + +/** + * @tc.number : HksDsaMT00600 + * @tc.name : HksDsaMT00600 + * @tc.desc : Test huks generate key (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00600, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_00600_PARAMS); +} + +/** + * @tc.number : HksDsaMT00700 + * @tc.name : HksDsaMT00700 + * @tc.desc : Test huks sign (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00700, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_00700_PARAMS); +} + +/** + * @tc.number : HksDsaMT00800 + * @tc.name : HksDsaMT00800 + * @tc.desc : Test huks sign (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00800, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_00800_PARAMS); +} + +/** + * @tc.number : HksDsaMT00900 + * @tc.name : HksDsaMT00900 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00900, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_00900_PARAMS); +} + +/** + * @tc.number : HksDsaMT01000 + * @tc.name : HksDsaMT01000 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01000, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_01000_PARAMS); +} + +/** + * @tc.number : HksDsaMT01100 + * @tc.name : HksDsaMT01100 + * @tc.desc : Test huks generate key (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_01100_PARAMS); +} + +/** + * @tc.number : HksDsaMT01200 + * @tc.name : HksDsaMT01200 + * @tc.desc : Test huks sign (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_01200_PARAMS); +} + +/** + * @tc.number : HksDsaMT01300 + * @tc.name : HksDsaMT01300 + * @tc.desc : Test huks sign (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_01300_PARAMS); +} + +/** + * @tc.number : HksDsaMT01400 + * @tc.name : HksDsaMT01400 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_01400_PARAMS); +} + +/** + * @tc.number : HksDsaMT01500 + * @tc.name : HksDsaMT01500 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_01500_PARAMS); +} + +/** + * @tc.number : HksDsaMT01600 + * @tc.name : HksDsaMT01600 + * @tc.desc : Test huks generate key (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01600, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_01600_PARAMS); +} + +/** + * @tc.number : HksDsaMT01700 + * @tc.name : HksDsaMT01700 + * @tc.desc : Test huks sign (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01700, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_01700_PARAMS); +} + +/** + * @tc.number : HksDsaMT01800 + * @tc.name : HksDsaMT01800 + * @tc.desc : Test huks sign (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01800, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_01800_PARAMS); +} + +/** + * @tc.number : HksDsaMT01900 + * @tc.name : HksDsaMT01900 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01900, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_01900_PARAMS); +} + +/** + * @tc.number : HksDsaMT02000 + * @tc.name : HksDsaMT02000 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02000, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_02000_PARAMS); +} + +/** + * @tc.number : HksDsaMT02100 + * @tc.name : HksDsaMT02100 + * @tc.desc : Test huks generate key (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_02100_PARAMS); +} + +/** + * @tc.number : HksDsaMT02200 + * @tc.name : HksDsaMT02200 + * @tc.desc : Test huks sign (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_02200_PARAMS); +} + +/** + * @tc.number : HksDsaMT02300 + * @tc.name : HksDsaMT02300 + * @tc.desc : Test huks sign (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_02300_PARAMS); +} + +/** + * @tc.number : HksDsaMT02400 + * @tc.name : HksDsaMT02400 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_02400_PARAMS); +} + +/** + * @tc.number : HksDsaMT02500 + * @tc.name : HksDsaMT02500 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_02500_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..b9d2636f63382cb096093c8148a941921d6ce4d7 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp @@ -0,0 +1,753 @@ +/* + * Copyright (C) 2021 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 "openssl_ecc_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const char ECC_KEY[] = "This is a ECC key"; + +const TestCaseParams HUKS_ECC_KEY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksEccKeyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(ECC_KEY), (uint8_t *)ECC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)HksMalloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)HksMalloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, digest, &message, &signature), testCaseParams.signResult); + EXPECT_EQ(EcdsaVerify(&pubKey, digest, &message, &signature), testCaseParams.verifyResult); + + HksFreeParamSet(¶mInSet); + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + HksFree(priKey.data); + HksFree(pubKey.data); + HksFree(signature.data); + } +}; + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00100 + * @tc.name : HksEccKeyMt00100 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00200 + * @tc.name : HksEccKeyMt00200 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00300 + * @tc.name : HksEccKeyMt00300 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00400 + * @tc.name : HksEccKeyMt00400 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00400_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00500 + * @tc.name : HksEccKeyMt00500 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00500_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00600 + * @tc.name : HksEccKeyMt00600 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00600_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00700 + * @tc.name : HksEccKeyMt00700 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00700_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00800 + * @tc.name : HksEccKeyMt00800 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00800_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00900 + * @tc.name : HksEccKeyMt00900 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00900_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01000 + * @tc.name : HksEccKeyMt01000 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01000_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01100 + * @tc.name : HksEccKeyMt01100 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01200 + * @tc.name : HksEccKeyMt01200 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01300 + * @tc.name : HksEccKeyMt01300 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01400 + * @tc.name : HksEccKeyMt01400 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01400_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01500 + * @tc.name : HksEccKeyMt01500 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01500_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01600 + * @tc.name : HksEccKeyMt01600 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01600_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01700 + * @tc.name : HksEccKeyMt01700 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01700_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01800 + * @tc.name : HksEccKeyMt01800 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01800_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01900 + * @tc.name : HksEccKeyMt01900 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01900_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02000 + * @tc.name : HksEccKeyMt02000 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02000_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02100 + * @tc.name : HksEccKeyMt02100 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02200 + * @tc.name : HksEccKeyMt02200 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02300 + * @tc.name : HksEccKeyMt02300 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02400 + * @tc.name : HksEccKeyMt02400 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02400_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d6ae913a9d9156277894c23cd1211c4aab2bb43c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp @@ -0,0 +1,1400 @@ +/* + * Copyright (C) 2021 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 "openssl_ecc_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const char ECC_KEY[] = "This is a ECC key"; + +const TestCaseParams HUKS_ECC_SIGN_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksEccSignMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(ECC_KEY), (uint8_t *)ECC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + if (storage == HKS_STORAGE_TEMP) { + authId = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + } + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + if (storage == HKS_STORAGE_TEMP) { + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + EXPECT_EQ(ECCGenerateKey(keySize, &authId), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + } else if (storage == HKS_STORAGE_PERSISTENT) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + } + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), testCaseParams.signResult); + EXPECT_EQ(EcdsaVerify(&pubKey, digest, &message, &signature), testCaseParams.verifyResult); + + if (storage == HKS_STORAGE_TEMP) { + HksFree(authId.data); + } + HksFreeParamSet(¶mInSet); + HksFree(pubKey.data); + HksFree(x509Key.data); + HksFree(signature.data); + } +}; + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00100 + * @tc.name : HksEccSignMt00100 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00100_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00200 + * @tc.name : HksEccSignMt00200 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00200_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00300 + * @tc.name : HksEccSignMt00300 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00300_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00400 + * @tc.name : HksEccSignMt00400 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00400_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00500 + * @tc.name : HksEccSignMt00500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00500_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00600 + * @tc.name : HksEccSignMt00600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00600_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00700 + * @tc.name : HksEccSignMt00700 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00700_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00800 + * @tc.name : HksEccSignMt00800 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00800_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt00900 + * @tc.name : HksEccSignMt00900 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00900_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01000 + * @tc.name : HksEccSignMt01000 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01000_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01100 + * @tc.name : HksEccSignMt01100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01100_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01200 + * @tc.name : HksEccSignMt01200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01200_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01300 + * @tc.name : HksEccSignMt01300 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01300_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01400 + * @tc.name : HksEccSignMt01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01400_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01500 + * @tc.name : HksEccSignMt01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01500_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01600 + * @tc.name : HksEccSignMt01600 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01600_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01700 + * @tc.name : HksEccSignMt01700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01700_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01800 + * @tc.name : HksEccSignMt01800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01800_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt01900 + * @tc.name : HksEccSignMt01900 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01900_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02000 + * @tc.name : HksEccSignMt02000 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02000_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02100 + * @tc.name : HksEccSignMt02100 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02100_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02200 + * @tc.name : HksEccSignMt02200 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02200_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02300 + * @tc.name : HksEccSignMt02300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02300_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02400 + * @tc.name : HksEccSignMt02400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02400_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02500 + * @tc.name : HksEccSignMt02500 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02500_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02600 + * @tc.name : HksEccSignMt02600 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02600_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02700 + * @tc.name : HksEccSignMt02700 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02700_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02800 + * @tc.name : HksEccSignMt02800 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02800_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt02900 + * @tc.name : HksEccSignMt02900 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02900_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03000 + * @tc.name : HksEccSignMt03000 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03000_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03100 + * @tc.name : HksEccSignMt03100 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03100_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03200 + * @tc.name : HksEccSignMt03200 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03200_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03300 + * @tc.name : HksEccSignMt03300 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03300_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03400 + * @tc.name : HksEccSignMt03400 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03400_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03500 + * @tc.name : HksEccSignMt03500 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03500_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03600 + * @tc.name : HksEccSignMt03600 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03600_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03700 + * @tc.name : HksEccSignMt03700 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03700_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03800 + * @tc.name : HksEccSignMt03800 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03800_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt03900 + * @tc.name : HksEccSignMt03900 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03900_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04000 + * @tc.name : HksEccSignMt04000 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04000_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04100 + * @tc.name : HksEccSignMt04100 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04100_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04200 + * @tc.name : HksEccSignMt04200 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04200_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04300 + * @tc.name : HksEccSignMt04300 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04300_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04400 + * @tc.name : HksEccSignMt04400 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04400_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04500 + * @tc.name : HksEccSignMt04500 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04500_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04600 + * @tc.name : HksEccSignMt04600 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04600_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04700 + * @tc.name : HksEccSignMt04700 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04700_PARAMS); +} + +/** + * @tc.number : HksEccSignMt.HksEccSignMt04800 + * @tc.name : HksEccSignMt04800 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt04800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_04800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..cf902b600960f6cfed60124ee74167e3b2c87848 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp @@ -0,0 +1,1396 @@ +/* + * Copyright (C) 2021 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 "openssl_ecc_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; +const char PUB_KEY[] = "This is a public key"; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksEccVerifyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + EXPECT_EQ(ECCGenerateKey(keySize, &authId), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, digest, &message, &signature), testCaseParams.signResult); + + if (storage == HKS_STORAGE_TEMP) { + EXPECT_EQ(HksVerify(&pubKey, paramInSet, &message, &signature), testCaseParams.verifyResult); + } else if (storage == HKS_STORAGE_PERSISTENT) { + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { (uint32_t)strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), testCaseParams.verifyResult); + HksFree(x509Key.data); + } + + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + HksFree(pubKey.data); + HksFree(signature.data); + } +}; + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00100 + * @tc.name : HksEccVerifyMt00100 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00100_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00200 + * @tc.name : HksEccVerifyMt00200 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00200_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00300 + * @tc.name : HksEccVerifyMt00300 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00300_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00400 + * @tc.name : HksEccVerifyMt00400 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00400_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00500 + * @tc.name : HksEccVerifyMt00500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00500_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00600 + * @tc.name : HksEccVerifyMt00600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00600_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00700 + * @tc.name : HksEccVerifyMt00700 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00700_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00800 + * @tc.name : HksEccVerifyMt00800 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00800_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00900 + * @tc.name : HksEccVerifyMt00900 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_00900_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01000 + * @tc.name : HksEccVerifyMt01000 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01000_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01100 + * @tc.name : HksEccVerifyMt01100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01100_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01200 + * @tc.name : HksEccVerifyMt01200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01200_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01300 + * @tc.name : HksEccVerifyMt01300 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01300_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01400 + * @tc.name : HksEccVerifyMt01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01400_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01500 + * @tc.name : HksEccVerifyMt01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01500_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01600 + * @tc.name : HksEccVerifyMt01600 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01600_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01700 + * @tc.name : HksEccVerifyMt01700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01700_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01800 + * @tc.name : HksEccVerifyMt01800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01800_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01900 + * @tc.name : HksEccVerifyMt01900 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01900_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02000 + * @tc.name : HksEccVerifyMt02000 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02000_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02100 + * @tc.name : HksEccVerifyMt02100 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02100_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02200 + * @tc.name : HksEccVerifyMt02200 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02200_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02300 + * @tc.name : HksEccVerifyMt02300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02300_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02400 + * @tc.name : HksEccVerifyMt02400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02400_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02500 + * @tc.name : HksEccVerifyMt02500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02500_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02600 + * @tc.name : HksEccVerifyMt02600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02600_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02700 + * @tc.name : HksEccVerifyMt02700 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02700_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02800 + * @tc.name : HksEccVerifyMt02800 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02800_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02900 + * @tc.name : HksEccVerifyMt02900 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_02900_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03000 + * @tc.name : HksEccVerifyMt03000 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03000_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03100 + * @tc.name : HksEccVerifyMt03100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03100_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03200 + * @tc.name : HksEccVerifyMt03200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03200_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03300 + * @tc.name : HksEccVerifyMt03300 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03300_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03400 + * @tc.name : HksEccVerifyMt03400 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03400_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03500 + * @tc.name : HksEccVerifyMt03500 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03500_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03600 + * @tc.name : HksEccVerifyMt03600 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03600_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03700 + * @tc.name : HksEccVerifyMt03700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03700_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03800 + * @tc.name : HksEccVerifyMt03800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03800_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03900 + * @tc.name : HksEccVerifyMt03900 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_03900_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04000 + * @tc.name : HksEccVerifyMt04000 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04000_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04100 + * @tc.name : HksEccVerifyMt04100 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04100_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04200 + * @tc.name : HksEccVerifyMt04200 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04200_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04300 + * @tc.name : HksEccVerifyMt04300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04300_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04400 + * @tc.name : HksEccVerifyMt04400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04400_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04500 + * @tc.name : HksEccVerifyMt04500 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04500_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04600 + * @tc.name : HksEccVerifyMt04600 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04600_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04700 + * @tc.name : HksEccVerifyMt04700 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04700_PARAMS); +} + +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04800 + * @tc.name : HksEccVerifyMt04800 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_04800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..f67457848196a3172e893f7b5bfa299609975fd7 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp @@ -0,0 +1,489 @@ +/* + * Copyright (C) 2021 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 "openssl_hmac_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode hmacResult; +}; + +const char HMAC_KEY[] = "This is a HMAC key"; + +const TestCaseParams HUKS_HMAC_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; +} // namespace + +class HksHmacMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksBlob authId = { (uint32_t)strlen(HMAC_KEY), (uint8_t *)HMAC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob macForHuks = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) }; + + if (storage == HKS_STORAGE_TEMP) { + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HMAC_KEY_SIZE, .data = (uint8_t *)HksMalloc(HMAC_KEY_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + if (scenario == 0) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult); + } else if (scenario == 1) { + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), testCaseParams.generateKeyResult); + } + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + HksBlob key = { .size = outParam->blob.size, .data = (uint8_t *)HksMalloc(outParam->blob.size) }; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + HksBlob macMessage = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) }; + + EXPECT_EQ(HmacHmac(&key, digest, &message, &macMessage), testCaseParams.hmacResult); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), testCaseParams.hmacResult); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + if (scenario == 1) { + HksFree(authId.data); + } + HksFreeParamSet(¶mOutSet); + HksFree(localKey.blob.data); + HksFree(macMessage.data); + HksFree(key.data); + } else if (storage == HKS_STORAGE_PERSISTENT) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), testCaseParams.hmacResult); + } + + HksFreeParamSet(¶mInSet); + HksFree(macForHuks.data); + } +}; + +/** + * @tc.number : HksHmacMt.HksHmacMt00100 + * @tc.name : HksHmacMt00100 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00100_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00200 + * @tc.name : HksHmacMt00200 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00200_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00300 + * @tc.name : HksHmacMt00300 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00300_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00400 + * @tc.name : HksHmacMt00400 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00400_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00500 + * @tc.name : HksHmacMt00500 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00500_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00600 + * @tc.name : HksHmacMt00600 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00600_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00700 + * @tc.name : HksHmacMt00700 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00700_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00800 + * @tc.name : HksHmacMt00800 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00800_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00900 + * @tc.name : HksHmacMt00900 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00900_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01000 + * @tc.name : HksHmacMt01000 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01000_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01100 + * @tc.name : HksHmacMt01100 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01100_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01200 + * @tc.name : HksHmacMt01200 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01200_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01300 + * @tc.name : HksHmacMt01300 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01300_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01400 + * @tc.name : HksHmacMt01400 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01400_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01500 + * @tc.name : HksHmacMt01500 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01500_PARAMS, 0); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..007aa6a443ceae14ab5a18f1d4fceaa6ae57338a --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp @@ -0,0 +1,522 @@ +/* + * Copyright (C) 2021 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 "hks_rsa_common_mt.h" +#include "openssl_rsa_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +} + +void HksRsaCommonMt::GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(paramSetOut); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo); + + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA( + &cipherText, &decryptedText, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + + EVP_PKEY_free(pkey); + HksFree(cipherText.data); + HksFree(x509Key.data); + HksFree(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult); + if (testCaseParams.decryptResult == HKS_SUCCESS) { + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + } + HksFree(decryptedText.data); + } + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult); + + if (testCaseParams.decryptResult == HKS_SUCCESS) { + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + } + HksFree(decryptedText.data); + } + + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::SignLocalTestCase(const SignLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.verifyResult); + HksFree(publicKey.data); + } + + HksFree(paramSetOut); + HksFree(privateKey.data); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::SignServiceTestCase(const SignServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.verifyResult); + HksFree(publicKey.data); + } + HksFree(paramSetOut); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + HksFree(publicKey.data); + } + HksFree(paramSetOut); + HksFree(privateKey.data); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo); + EXPECT_EQ( + OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + } + EVP_PKEY_free(pkey); + HksFree(signData.data); + HksFree(x509Key.data); + HksFree(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..f60a6040258b775dc8cefa423997fea9a667455f --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp @@ -0,0 +1,1177 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_00100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_00200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_00300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_00400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_00500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_00600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_00700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_00800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptLocalCaseParams HKS_RSA_MT_00900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_01000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptLocalCaseParams HKS_RSA_MT_01100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_01200_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptLocalCaseParams HKS_RSA_MT_01300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_01400_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptLocalCaseParams HKS_RSA_MT_01500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_01600_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptLocalCaseParams HKS_RSA_MT_01700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const EncryptServiceCaseParams HKS_RSA_MT_01800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_01900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_02000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_02100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_02200_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_02300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_02400_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_02500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_02600_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_02700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_02800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptLocalCaseParams HKS_RSA_MT_02900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const DecryptServiceCaseParams HKS_RSA_MT_03000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +} // namespace + +class HksRsaEcbNopaddingMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbNopaddingMt00100 + * @tc.name : HksRsaEcbNopaddingMt00100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00200 + * @tc.name : HksRsaEcbNopaddingMt00200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00300 + * @tc.name : HksRsaEcbNopaddingMt00300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00400 + * @tc.name : HksRsaEcbNopaddingMt00400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00500 + * @tc.name : HksRsaEcbNopaddingMt00500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00600 + * @tc.name : HksRsaEcbNopaddingMt00600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00700 + * @tc.name : HksRsaEcbNopaddingMt00700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_00700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00800 + * @tc.name : HksRsaEcbNopaddingMt00800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_00800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt00900 + * @tc.name : HksRsaEcbNopaddingMt00900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_00900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01000 + * @tc.name : HksRsaEcbNopaddingMt01000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01100 + * @tc.name : HksRsaEcbNopaddingMt01100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01200 + * @tc.name : HksRsaEcbNopaddingMt01200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01300 + * @tc.name : HksRsaEcbNopaddingMt01300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01400 + * @tc.name : HksRsaEcbNopaddingMt01400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01500 + * @tc.name : HksRsaEcbNopaddingMt01500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01600 + * @tc.name : HksRsaEcbNopaddingMt01600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01700 + * @tc.name : HksRsaEcbNopaddingMt01700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01800 + * @tc.name : HksRsaEcbNopaddingMt01800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt01900 + * @tc.name : HksRsaEcbNopaddingMt01900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_01900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02000 + * @tc.name : HksRsaEcbNopaddingMt02000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_02000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02100 + * @tc.name : HksRsaEcbNopaddingMt02100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_02100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02200 + * @tc.name : HksRsaEcbNopaddingMt02200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_02200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02300 + * @tc.name : HksRsaEcbNopaddingMt02300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_02300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02400 + * @tc.name : HksRsaEcbNopaddingMt02400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_02400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02500 + * @tc.name : HksRsaEcbNopaddingMt02500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_02500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02600 + * @tc.name : HksRsaEcbNopaddingMt02600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_02600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02700 + * @tc.name : HksRsaEcbNopaddingMt02700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_02700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02800 + * @tc.name : HksRsaEcbNopaddingMt02800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_02800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt02900 + * @tc.name : HksRsaEcbNopaddingMt02900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_02900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbNopaddingMt03000 + * @tc.name : HksRsaEcbNopaddingMt03000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt03000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_03000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a2d841fb08179b4664addced2976404c27a4bcb3 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp @@ -0,0 +1,993 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_03100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_03200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_03300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_03400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_03500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_03600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_03700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_03800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_03900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_04000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_04100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_04200_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_04300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_04400_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_04500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_04600_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +const EncryptLocalCaseParams HKS_RSA_MT_04700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_04800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_04900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_05000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_05100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_05200_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_05300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_05400_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_05500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_05600_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_05700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_05800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_05900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_06000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepPaddingMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03100 + * @tc.name : HksRsaEcbOaepPaddingMt03100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03200 + * @tc.name : HksRsaEcbOaepPaddingMt03200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03300 + * @tc.name : HksRsaEcbOaepPaddingMt03300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03400 + * @tc.name : HksRsaEcbOaepPaddingMt03400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03500 + * @tc.name : HksRsaEcbOaepPaddingMt03500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03600 + * @tc.name : HksRsaEcbOaepPaddingMt03600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03700 + * @tc.name : HksRsaEcbOaepPaddingMt03700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_03700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03800 + * @tc.name : HksRsaEcbOaepPaddingMt03800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_03800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt03900 + * @tc.name : HksRsaEcbOaepPaddingMt03900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_03900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04000 + * @tc.name : HksRsaEcbOaepPaddingMt04000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_04000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04100 + * @tc.name : HksRsaEcbOaepPaddingMt04100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_04100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04200 + * @tc.name : HksRsaEcbOaepPaddingMt04200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_04200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04300 + * @tc.name : HksRsaEcbOaepPaddingMt04300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_04300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04400 + * @tc.name : HksRsaEcbOaepPaddingMt04400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_04400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04500 + * @tc.name : HksRsaEcbOaepPaddingMt04500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_04500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04600 + * @tc.name : HksRsaEcbOaepPaddingMt04600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_04600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04700 + * @tc.name : HksRsaEcbOaepPaddingMt04700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_04700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04800 + * @tc.name : HksRsaEcbOaepPaddingMt04800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_04800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt04900 + * @tc.name : HksRsaEcbOaepPaddingMt04900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04900, TestSize.Level1) + +{ + DecryptLocalTestCase(HKS_RSA_MT_04900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05000 + * @tc.name : HksRsaEcbOaepPaddingMt05000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_05000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05100 + * @tc.name : HksRsaEcbOaepPaddingMt05100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_05100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05200 + * @tc.name : HksRsaEcbOaepPaddingMt05200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_05200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05300 + * @tc.name : HksRsaEcbOaepPaddingMt05300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_05300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05400 + * @tc.name : HksRsaEcbOaepPaddingMt05400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_05400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05500 + * @tc.name : HksRsaEcbOaepPaddingMt05500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_05500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05600 + * @tc.name : HksRsaEcbOaepPaddingMt05600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_05600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05700 + * @tc.name : HksRsaEcbOaepPaddingMt05700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_05700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05800 + * @tc.name : HksRsaEcbOaepPaddingMt05800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_05800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt05900 + * @tc.name : HksRsaEcbOaepPaddingMt05900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_05900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepPaddingMt06000 + * @tc.name : HksRsaEcbOaepPaddingMt06000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt06000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_06000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a0d9419623ac3d95b962080b80f7dd3c6bb74099 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp @@ -0,0 +1,995 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_06100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_06200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_06300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_06400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_06500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_06600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_06700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_06800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_06900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_07000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_07100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_07200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_07300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_07400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_07500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_07600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_07700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_07800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_07900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_08000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_08100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_08200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_08300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_08400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_08500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_08600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_08700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_08800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_08900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_09000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha1Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06100 + * @tc.name : HksRsaEcbOaepSha1Mt06100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06200 + * @tc.name : HksRsaEcbOaepSha1Mt06200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06300 + * @tc.name : HksRsaEcbOaepSha1Mt06300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06400 + * @tc.name : HksRsaEcbOaepSha1Mt06400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06500 + * @tc.name : HksRsaEcbOaepSha1Mt06500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06600 + * @tc.name : HksRsaEcbOaepSha1Mt06600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06700 + * @tc.name : HksRsaEcbOaepSha1Mt06700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_06700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06800 + * @tc.name : HksRsaEcbOaepSha1Mt06800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_06800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt06900 + * @tc.name : HksRsaEcbOaepSha1Mt06900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_06900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07000 + * @tc.name : HksRsaEcbOaepSha1Mt07000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_07000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07100 + * @tc.name : HksRsaEcbOaepSha1Mt07100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_07100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07200 + * @tc.name : HksRsaEcbOaepSha1Mt07200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_07200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07300 + * @tc.name : HksRsaEcbOaepSha1Mt07300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_07300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07400 + * @tc.name : HksRsaEcbOaepSha1Mt07400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_07400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07500 + * @tc.name : HksRsaEcbOaepSha1Mt07500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_07500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07600 + * @tc.name : HksRsaEcbOaepSha1Mt07600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_07600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07700 + * @tc.name : HksRsaEcbOaepSha1Mt07700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_07700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07800 + * @tc.name : HksRsaEcbOaepSha1Mt07800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_07800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt07900 + * @tc.name : HksRsaEcbOaepSha1Mt07900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_07900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08000 + * @tc.name : HksRsaEcbOaepSha1Mt08000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_08000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08100 + * @tc.name : HksRsaEcbOaepSha1Mt08100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_08100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08200 + * @tc.name : HksRsaEcbOaepSha1Mt08200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_08200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08300 + * @tc.name : HksRsaEcbOaepSha1Mt08300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_08300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08400 + * @tc.name : HksRsaEcbOaepSha1Mt08400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_08400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08500 + * @tc.name : HksRsaEcbOaepSha1Mt08500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_08500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08600 + * @tc.name : HksRsaEcbOaepSha1Mt08600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_08600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08700 + * @tc.name : HksRsaEcbOaepSha1Mt08700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_08700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08800 + * @tc.name : HksRsaEcbOaepSha1Mt08800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_08800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt08900 + * @tc.name : HksRsaEcbOaepSha1Mt08900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_08900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha1Mt09000 + * @tc.name : HksRsaEcbOaepSha1Mt09000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt09000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_09000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ee44b8c83979542055d75e528e2ab5eaee475c8b --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp @@ -0,0 +1,995 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_09100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_09200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_09300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_09400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_09500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_09600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_09700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_09800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_09900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_10000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_10100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_10200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_10300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_10400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_10500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_10600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_10700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_10800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_10900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_11000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_11100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_11200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_11300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_11400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_11500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_11600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_11700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_11800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_11900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_12000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha224Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09100 + * @tc.name : HksRsaEcbOaepSha224Mt09100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09200 + * @tc.name : HksRsaEcbOaepSha224Mt09200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09300 + * @tc.name : HksRsaEcbOaepSha224Mt09300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09400 + * @tc.name : HksRsaEcbOaepSha224Mt09400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09500 + * @tc.name : HksRsaEcbOaepSha224Mt09500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09600 + * @tc.name : HksRsaEcbOaepSha224Mt09600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09700 + * @tc.name : HksRsaEcbOaepSha224Mt09700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_09700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09800 + * @tc.name : HksRsaEcbOaepSha224Mt09800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_09800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt09900 + * @tc.name : HksRsaEcbOaepSha224Mt09900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_09900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10000 + * @tc.name : HksRsaEcbOaepSha224Mt10000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_10000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10100 + * @tc.name : HksRsaEcbOaepSha224Mt10100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_10100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10200 + * @tc.name : HksRsaEcbOaepSha224Mt10200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_10200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10300 + * @tc.name : HksRsaEcbOaepSha224Mt10300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_10300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10400 + * @tc.name : HksRsaEcbOaepSha224Mt10400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_10400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10500 + * @tc.name : HksRsaEcbOaepSha224Mt10500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_10500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10600 + * @tc.name : HksRsaEcbOaepSha224Mt10600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_10600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10700 + * @tc.name : HksRsaEcbOaepSha224Mt10700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_10700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10800 + * @tc.name : HksRsaEcbOaepSha224Mt10800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_10800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt10900 + * @tc.name : HksRsaEcbOaepSha224Mt10900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_10900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11000 + * @tc.name : HksRsaEcbOaepSha224Mt11000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_11000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11100 + * @tc.name : HksRsaEcbOaepSha224Mt11100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_11100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11200 + * @tc.name : HksRsaEcbOaepSha224Mt11200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_11200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11300 + * @tc.name : HksRsaEcbOaepSha224Mt11300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_11300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11400 + * @tc.name : HksRsaEcbOaepSha224Mt11400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_11400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11500 + * @tc.name : HksRsaEcbOaepSha224Mt11500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_11500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11600 + * @tc.name : HksRsaEcbOaepSha224Mt11600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_11600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11700 + * @tc.name : HksRsaEcbOaepSha224Mt11700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_11700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11800 + * @tc.name : HksRsaEcbOaepSha224Mt11800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_11800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt11900 + * @tc.name : HksRsaEcbOaepSha224Mt11900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_11900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha224Mt12000 + * @tc.name : HksRsaEcbOaepSha224Mt12000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt12000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_12000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..2f3b4f3990d39db4c2d3df0ad781fed68a3f17c8 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp @@ -0,0 +1,995 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_12100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_12200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_12300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_12400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_12500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_12600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_12700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_12800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_12900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_13100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_13300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_13500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_13700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_13900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_14000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_14100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_14200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_14300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_14400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_14500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_14600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_14700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_14800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_14900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_15000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha256Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12100 + * @tc.name : HksRsaEcbOaepSha256Mt12100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12200 + * @tc.name : HksRsaEcbOaepSha256Mt12200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12300 + * @tc.name : HksRsaEcbOaepSha256Mt12300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12400 + * @tc.name : HksRsaEcbOaepSha256Mt12400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12500 + * @tc.name : HksRsaEcbOaepSha256Mt12500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12600 + * @tc.name : HksRsaEcbOaepSha256Mt12600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12700 + * @tc.name : HksRsaEcbOaepSha256Mt12700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_12700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12800 + * @tc.name : HksRsaEcbOaepSha256Mt12800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_12800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt12900 + * @tc.name : HksRsaEcbOaepSha256Mt12900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_12900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13000 + * @tc.name : HksRsaEcbOaepSha256Mt13000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_13000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13100 + * @tc.name : HksRsaEcbOaepSha256Mt13100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_13100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13200 + * @tc.name : HksRsaEcbOaepSha256Mt13200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_13200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13300 + * @tc.name : HksRsaEcbOaepSha256Mt13300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_13300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13400 + * @tc.name : HksRsaEcbOaepSha256Mt13400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_13400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt00100 + * @tc.name : HksRsaEcbOaepSha256Mt00100 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_13500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13600 + * @tc.name : HksRsaEcbOaepSha256Mt13600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_13600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13700 + * @tc.name : HksRsaEcbOaepSha256Mt13700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_13700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13800 + * @tc.name : HksRsaEcbOaepSha256Mt13800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_13800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt13900 + * @tc.name : HksRsaEcbOaepSha256Mt13900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_13900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14000 + * @tc.name : HksRsaEcbOaepSha256Mt14000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_14000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14100 + * @tc.name : HksRsaEcbOaepSha256Mt14100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_14100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14200 + * @tc.name : HksRsaEcbOaepSha256Mt14200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_14200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14300 + * @tc.name : HksRsaEcbOaepSha256Mt14300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_14300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14400 + * @tc.name : HksRsaEcbOaepSha256Mt14400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_14400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14500 + * @tc.name : HksRsaEcbOaepSha256Mt14500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_14500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14600 + * @tc.name : HksRsaEcbOaepSha256Mt14600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_14600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14700 + * @tc.name : HksRsaEcbOaepSha256Mt14700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_14700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14800 + * @tc.name : HksRsaEcbOaepSha256Mt14800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_14800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt14900 + * @tc.name : HksRsaEcbOaepSha256Mt14900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_14900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha256Mt15000 + * @tc.name : HksRsaEcbOaepSha256Mt15000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt15000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_15000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..3dbeb8b245950c5f5836f98ccea83977d6751710 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp @@ -0,0 +1,995 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_15100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_15700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_15800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_15900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_16100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_16300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_16500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_16700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_16900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_17000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_17100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_17200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_17300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_17400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_17500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_17600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_17700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_17800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_17900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_18000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha384Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15100 + * @tc.name : HksRsaEcbOaepSha384Mt15100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15200 + * @tc.name : HksRsaEcbOaepSha384Mt15200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15300 + * @tc.name : HksRsaEcbOaepSha384Mt15300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15400 + * @tc.name : HksRsaEcbOaepSha384Mt15400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15500 + * @tc.name : HksRsaEcbOaepSha384Mt15500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15600 + * @tc.name : HksRsaEcbOaepSha384Mt15600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15700 + * @tc.name : HksRsaEcbOaepSha384Mt15700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_15700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15800 + * @tc.name : HksRsaEcbOaepSha384Mt15800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_15800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15900 + * @tc.name : HksRsaEcbOaepSha384Mt15900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_15900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16000 + * @tc.name : HksRsaEcbOaepSha384Mt16000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_16000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16100 + * @tc.name : HksRsaEcbOaepSha384Mt16100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_16100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16200 + * @tc.name : HksRsaEcbOaepSha384Mt16200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_16200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16300 + * @tc.name : HksRsaEcbOaepSha384Mt16300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_16300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16400 + * @tc.name : HksRsaEcbOaepSha384Mt16400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_16400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16500 + * @tc.name : HksRsaEcbOaepSha384Mt16500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_16500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16600 + * @tc.name : HksRsaEcbOaepSha384Mt16600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_16600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16700 + * @tc.name : HksRsaEcbOaepSha384Mt16700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_16700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16800 + * @tc.name : HksRsaEcbOaepSha384Mt16800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_16800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt16900 + * @tc.name : HksRsaEcbOaepSha384Mt16900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_16900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17000 + * @tc.name : HksRsaEcbOaepSha384Mt17000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_17000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17100 + * @tc.name : HksRsaEcbOaepSha384Mt17100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_17100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17200 + * @tc.name : HksRsaEcbOaepSha384Mt17200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_17200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17300 + * @tc.name : HksRsaEcbOaepSha384Mt17300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_17300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17400 + * @tc.name : HksRsaEcbOaepSha384Mt17400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_17400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17500 + * @tc.name : HksRsaEcbOaepSha384Mt17500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_17500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17600 + * @tc.name : HksRsaEcbOaepSha384Mt17600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_17600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17700 + * @tc.name : HksRsaEcbOaepSha384Mt17700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_17700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17800 + * @tc.name : HksRsaEcbOaepSha384Mt17800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_17800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt17900 + * @tc.name : HksRsaEcbOaepSha384Mt17900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_17900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt18000 + * @tc.name : HksRsaEcbOaepSha384Mt18000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt18000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_18000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..702ebde2a7514e862b010fa3a0424f4756ce87b9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp @@ -0,0 +1,995 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_18100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_18200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_18300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_18400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_18500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_18600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_18700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_18800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_18900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_19000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_19100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_19200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_19300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_19400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_19500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_19600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_19700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_19800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_19900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_20100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_20300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_20500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_20700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_20900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_21000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha512Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18100 + * @tc.name : HksRsaEcbOaepSha512Mt18100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18200 + * @tc.name : HksRsaEcbOaepSha512Mt18200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18300 + * @tc.name : HksRsaEcbOaepSha512Mt18300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18400 + * @tc.name : HksRsaEcbOaepSha512Mt18400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18500 + * @tc.name : HksRsaEcbOaepSha512Mt18500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18600 + * @tc.name : HksRsaEcbOaepSha512Mt18600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18700 + * @tc.name : HksRsaEcbOaepSha512Mt18700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_18700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18800 + * @tc.name : HksRsaEcbOaepSha512Mt18800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_18800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18900 + * @tc.name : HksRsaEcbOaepSha512Mt18900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_18900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19000 + * @tc.name : HksRsaEcbOaepSha512Mt19000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_19000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19100 + * @tc.name : HksRsaEcbOaepSha512Mt19100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_19100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19200 + * @tc.name : HksRsaEcbOaepSha512Mt19200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_19200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19300 + * @tc.name : HksRsaEcbOaepSha512Mt19300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_19300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19400 + * @tc.name : HksRsaEcbOaepSha512Mt19400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_19400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19500 + * @tc.name : HksRsaEcbOaepSha512Mt19500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_19500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19600 + * @tc.name : HksRsaEcbOaepSha512Mt19600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_19600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19700 + * @tc.name : HksRsaEcbOaepSha512Mt19700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_19700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19800 + * @tc.name : HksRsaEcbOaepSha512Mt19800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_19800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt19900 + * @tc.name : HksRsaEcbOaepSha512Mt19900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_19900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20000 + * @tc.name : HksRsaEcbOaepSha512Mt20000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_20000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20100 + * @tc.name : HksRsaEcbOaepSha512Mt20100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_20100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20200 + * @tc.name : HksRsaEcbOaepSha512Mt20200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_20200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20300 + * @tc.name : HksRsaEcbOaepSha512Mt20300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_20300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20400 + * @tc.name : HksRsaEcbOaepSha512Mt20400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_20400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20500 + * @tc.name : HksRsaEcbOaepSha512Mt20500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_20500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20600 + * @tc.name : HksRsaEcbOaepSha512Mt20600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_20600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20700 + * @tc.name : HksRsaEcbOaepSha512Mt20700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_20700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20800 + * @tc.name : HksRsaEcbOaepSha512Mt20800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_20800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt20900 + * @tc.name : HksRsaEcbOaepSha512Mt20900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_20900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt21000 + * @tc.name : HksRsaEcbOaepSha512Mt21000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt21000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_21000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..74c727a22e1699574fae1d884064dfae0b06e252 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp @@ -0,0 +1,1024 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const GenerateKeyCaseParams HKS_RSA_MT_21100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_21200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_21300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_21400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_21500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_21600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_21700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_21800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_21900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_22000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_22100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_22200_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_22300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_22400_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_22500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_22600_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_22700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_22800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_22900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_23000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_23100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_23200_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_23300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_23400_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_23500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_23600_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_23700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_23800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptLocalCaseParams HKS_RSA_MT_23900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_24000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbPkcs1PaddingMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21100 + * @tc.name : HksRsaEcbPkcs1PaddingMt21100 + * @tc.desc : Test huks generate key (512_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21200 + * @tc.name : HksRsaEcbPkcs1PaddingMt21200 + * @tc.desc : Test huks generate key (768_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21300 + * @tc.name : HksRsaEcbPkcs1PaddingMt21300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21400 + * @tc.name : HksRsaEcbPkcs1PaddingMt21400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21500 + * @tc.name : HksRsaEcbPkcs1PaddingMt21500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21600 + * @tc.name : HksRsaEcbPkcs1PaddingMt21600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21700 + * @tc.name : HksRsaEcbPkcs1PaddingMt21700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_21700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21800 + * @tc.name : HksRsaEcbPkcs1PaddingMt21800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_21800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21900 + * @tc.name : HksRsaEcbPkcs1PaddingMt21900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/PKCS1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_21900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22000 + * @tc.name : HksRsaEcbPkcs1PaddingMt22000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_22000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22100 + * @tc.name : HksRsaEcbPkcs1PaddingMt22100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_22100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22200 + * @tc.name : HksRsaEcbPkcs1PaddingMt22200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_22200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22300 + * @tc.name : HksRsaEcbPkcs1PaddingMt22300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_22300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22400 + * @tc.name : HksRsaEcbPkcs1PaddingMt22400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_22400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22500 + * @tc.name : HksRsaEcbPkcs1PaddingMt22500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_22500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22600 + * @tc.name : HksRsaEcbPkcs1PaddingMt22600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_22600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22700 + * @tc.name : HksRsaEcbPkcs1PaddingMt22700 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_22700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22800 + * @tc.name : HksRsaEcbPkcs1PaddingMt22800 + * @tc.desc : Test huks Encrypt (4096_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_22800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt22900 + * @tc.name : HksRsaEcbPkcs1PaddingMt22900 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_22900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23000 + * @tc.name : HksRsaEcbPkcs1PaddingMt23000 + * @tc.desc : Test huks Decrypt (512_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_23000_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23100 + * @tc.name : HksRsaEcbPkcs1PaddingMt23100 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23100, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_23100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23200 + * @tc.name : HksRsaEcbPkcs1PaddingMt23200 + * @tc.desc : Test huks Decrypt (768_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23200, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_23200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23300 + * @tc.name : HksRsaEcbPkcs1PaddingMt23300 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23300, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_23300_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23400 + * @tc.name : HksRsaEcbPkcs1PaddingMt23400 + * @tc.desc : Test huks Decrypt (1024_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23400, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_23400_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23500 + * @tc.name : HksRsaEcbPkcs1PaddingMt23500 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23500, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_23500_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23600 + * @tc.name : HksRsaEcbPkcs1PaddingMt23600 + * @tc.desc : Test huks Decrypt (2048_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23600, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_23600_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23700 + * @tc.name : HksRsaEcbPkcs1PaddingMt23700 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23700, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_23700_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23800 + * @tc.name : HksRsaEcbPkcs1PaddingMt23800 + * @tc.desc : Test huks Decrypt (3072_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23800, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_23800_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt23900 + * @tc.name : HksRsaEcbPkcs1PaddingMt23900 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23900, TestSize.Level1) +{ + DecryptLocalTestCase(HKS_RSA_MT_23900_PARAMS); +} + +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt24000 + * @tc.name : HksRsaEcbPkcs1PaddingMt24000 + * @tc.desc : Test huks Decrypt (4096_RSA/ECB/PKCS1Padding/PERSISTENT) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt24000, TestSize.Level1) +{ + DecryptServiceTestCase(HKS_RSA_MT_24000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..5934d1e717aea2f5c8e0cdbded07937eb6c6b60f --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_24100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_24200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_24300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_24400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_24500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_24600_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_24700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_24800_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_24900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_25000_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_25100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_25200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_25300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_25400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_25500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_25600_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_25700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_25800_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_25900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_26000_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_26100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_26200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_26300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_26400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaMd5WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaMd5WithRsaMt24100 + * @tc.name : HksRsaMd5WithRsaMt24100 + * @tc.desc : Test huks sign (512/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_24100_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24200 + * @tc.name : HksRsaMd5WithRsaMt24200 + * @tc.desc : Test huks sign (512/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_24200_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24300 + * @tc.name : HksRsaMd5WithRsaMt24300 + * @tc.desc : Test huks Verify (512/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_24300_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24400 + * @tc.name : HksRsaMd5WithRsaMt24400 + * @tc.desc : Test huks Verify (512/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_24400_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24500 + * @tc.name : HksRsaMd5WithRsaMt24500 + * @tc.desc : Test huks sign (768/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_24500_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24600 + * @tc.name : HksRsaMd5WithRsaMt24600 + * @tc.desc : Test huks sign (768/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_24600_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24700 + * @tc.name : HksRsaMd5WithRsaMt24700 + * @tc.desc : Test huks Verify (768/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_24700_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24800 + * @tc.name : HksRsaMd5WithRsaMt24800 + * @tc.desc : Test huks Verify (768/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_24800_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt24900 + * @tc.name : HksRsaMd5WithRsaMt24900 + * @tc.desc : Test huks sign (1024/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_24900_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25000 + * @tc.name : HksRsaMd5WithRsaMt25000 + * @tc.desc : Test huks sign (1024/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_25000_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25100 + * @tc.name : HksRsaMd5WithRsaMt25100 + * @tc.desc : Test huks Verify (1024/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_25100_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25200 + * @tc.name : HksRsaMd5WithRsaMt25200 + * @tc.desc : Test huks Verify (1024/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_25200_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25300 + * @tc.name : HksRsaMd5WithRsaMt25300 + * @tc.desc : Test huks sign (2048/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_25300_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25400 + * @tc.name : HksRsaMd5WithRsaMt25400 + * @tc.desc : Test huks sign (2048/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_25400_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25500 + * @tc.name : HksRsaMd5WithRsaMt25500 + * @tc.desc : Test huks Verify (2048/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_25500_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25600 + * @tc.name : HksRsaMd5WithRsaMt25600 + * @tc.desc : Test huks Verify (2048/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_25600_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25700 + * @tc.name : HksRsaMd5WithRsaMt25700 + * @tc.desc : Test huks sign (3072/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_25700_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25800 + * @tc.name : HksRsaMd5WithRsaMt25800 + * @tc.desc : Test huks sign (3072/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_25800_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt25900 + * @tc.name : HksRsaMd5WithRsaMt25900 + * @tc.desc : Test huks Verify (3072/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_25900_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt26000 + * @tc.name : HksRsaMd5WithRsaMt26000 + * @tc.desc : Test huks Verify (3072/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_26000_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt26100 + * @tc.name : HksRsaMd5WithRsaMt26100 + * @tc.desc : Test huks sign (4096/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_26100_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt26200 + * @tc.name : HksRsaMd5WithRsaMt26200 + * @tc.desc : Test huks sign (4096/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_26200_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt26300 + * @tc.name : HksRsaMd5WithRsaMt26300 + * @tc.desc : Test huks Verify (4096/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_26300_PARAMS); +} + +/** + * @tc.number : HksRsaMd5WithRsaMt26400 + * @tc.name : HksRsaMd5WithRsaMt26400 + * @tc.desc : Test huks Verify (4096/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_26400_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..c3ce2fefc2f628376d795608c75161203dba7202 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_26500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_26600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_26700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_26800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_26900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_27000_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_27100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_27200_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_27300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_27400_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_27500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_27600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_27700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_27800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_27900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_28000_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_28100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_28200_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_28300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_28400_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_28500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_28600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_28700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_28800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaNoneWithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaNoneWithRsaMt26500 + * @tc.name : HksRsaNoneWithRsaMt26500 + * @tc.desc : Test huks sign (512/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_26500_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt26600 + * @tc.name : HksRsaNoneWithRsaMt26600 + * @tc.desc : Test huks sign (512/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_26600_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt26700 + * @tc.name : HksRsaNoneWithRsaMt26700 + * @tc.desc : Test huks Verify (512/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_26700_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt26800 + * @tc.name : HksRsaNoneWithRsaMt26800 + * @tc.desc : Test huks Verify (512/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_26800_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt26900 + * @tc.name : HksRsaNoneWithRsaMt26900 + * @tc.desc : Test huks sign (768/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_26900_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27000 + * @tc.name : HksRsaNoneWithRsaMt27000 + * @tc.desc : Test huks sign (768/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_27000_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27100 + * @tc.name : HksRsaNoneWithRsaMt27100 + * @tc.desc : Test huks Verify (768/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_27100_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27200 + * @tc.name : HksRsaNoneWithRsaMt27200 + * @tc.desc : Test huks Verify (768/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_27200_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27300 + * @tc.name : HksRsaNoneWithRsaMt27300 + * @tc.desc : Test huks sign (1024/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_27300_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27400 + * @tc.name : HksRsaNoneWithRsaMt27400 + * @tc.desc : Test huks sign (1024/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_27400_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27500 + * @tc.name : HksRsaNoneWithRsaMt27500 + * @tc.desc : Test huks Verify (1024/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_27500_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27600 + * @tc.name : HksRsaNoneWithRsaMt27600 + * @tc.desc : Test huks Verify (1024/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_27600_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27700 + * @tc.name : HksRsaNoneWithRsaMt27700 + * @tc.desc : Test huks sign (2048/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_27700_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27800 + * @tc.name : HksRsaNoneWithRsaMt27800 + * @tc.desc : Test huks sign (2048/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_27800_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt27900 + * @tc.name : HksRsaNoneWithRsaMt27900 + * @tc.desc : Test huks Verify (2048/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_27900_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28000 + * @tc.name : HksRsaNoneWithRsaMt28000 + * @tc.desc : Test huks Verify (2048/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_28000_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28100 + * @tc.name : HksRsaNoneWithRsaMt28100 + * @tc.desc : Test huks sign (3072/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_28100_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28200 + * @tc.name : HksRsaNoneWithRsaMt28200 + * @tc.desc : Test huks sign (3072/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_28200_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28300 + * @tc.name : HksRsaNoneWithRsaMt28300 + * @tc.desc : Test huks Verify (3072/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_28300_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28400 + * @tc.name : HksRsaNoneWithRsaMt28400 + * @tc.desc : Test huks Verify (3072/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_28400_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28500 + * @tc.name : HksRsaNoneWithRsaMt28500 + * @tc.desc : Test huks sign (4096/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_28500_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28600 + * @tc.name : HksRsaNoneWithRsaMt28600 + * @tc.desc : Test huks sign (4096/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_28600_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28700 + * @tc.name : HksRsaNoneWithRsaMt28700 + * @tc.desc : Test huks Verify (4096/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_28700_PARAMS); +} + +/** + * @tc.number : HksRsaNoneWithRsaMt28800 + * @tc.name : HksRsaNoneWithRsaMt28800 + * @tc.desc : Test huks Verify (4096/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_28800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..02886e8a64c3ff2ddd239e0d07ec891195fffd0e --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_28900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_29000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_29100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_29200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_29300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_29400_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_29500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_29600_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_29700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_29800_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_29900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_30000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_30100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_30200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_30300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_30400_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_30500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_30600_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_30700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_30800_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_30900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_31000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_31100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_31200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha1WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha1WithRsaMt28900 + * @tc.name : HksRsaSha1WithRsaMt28900 + * @tc.desc : Test huks sign (512/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt28900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_28900_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29000 + * @tc.name : HksRsaSha1WithRsaMt29000 + * @tc.desc : Test huks sign (512/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_29000_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29100 + * @tc.name : HksRsaSha1WithRsaMt29100 + * @tc.desc : Test huks Verify (512/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_29100_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29200 + * @tc.name : HksRsaSha1WithRsaMt29200 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_29200_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29300 + * @tc.name : HksRsaSha1WithRsaMt29300 + * @tc.desc : Test huks sign (768/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_29300_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29400 + * @tc.name : HksRsaSha1WithRsaMt29400 + * @tc.desc : Test huks sign (768/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_29400_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29500 + * @tc.name : HksRsaSha1WithRsaMt29500 + * @tc.desc : Test huks Verify (768/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_29500_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29600 + * @tc.name : HksRsaSha1WithRsaMt29600 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_29600_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29700 + * @tc.name : HksRsaSha1WithRsaMt29700 + * @tc.desc : Test huks sign (1024/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_29700_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29800 + * @tc.name : HksRsaSha1WithRsaMt29800 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_29800_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt29900 + * @tc.name : HksRsaSha1WithRsaMt29900 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_29900_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30000 + * @tc.name : HksRsaSha1WithRsaMt30000 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_30000_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30100 + * @tc.name : HksRsaSha1WithRsaMt30100 + * @tc.desc : Test huks sign (2048/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_30100_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30200 + * @tc.name : HksRsaSha1WithRsaMt30200 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_30200_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30300 + * @tc.name : HksRsaSha1WithRsaMt30300 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_30300_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30400 + * @tc.name : HksRsaSha1WithRsaMt30400 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_30400_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30500 + * @tc.name : HksRsaSha1WithRsaMt30500 + * @tc.desc : Test huks sign (3072/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_30500_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30600 + * @tc.name : HksRsaSha1WithRsaMt30600 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_30600_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30700 + * @tc.name : HksRsaSha1WithRsaMt30700 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_30700_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30800 + * @tc.name : HksRsaSha1WithRsaMt30800 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_30800_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt30900 + * @tc.name : HksRsaSha1WithRsaMt30900 + * @tc.desc : Test huks sign (4096/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_30900_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt31000 + * @tc.name : HksRsaSha1WithRsaMt31000 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_31000_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt31100 + * @tc.name : HksRsaSha1WithRsaMt31100 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_31100_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaMt31200 + * @tc.name : HksRsaSha1WithRsaMt31200 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_31200_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a8babfbee7b7067399dd8e88804a13a8a28b6392 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_31300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_31400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_31500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_31600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_31700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_31800_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_31900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_32000_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_32100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_32200_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_32300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_32400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_32500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_32600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_32700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_32800_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_32900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_33000_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_33100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_33200_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_33300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_33400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_33500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_33600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha1WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31300 + * @tc.name : HksRsaSha1WithRsaPssMt31300 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_31300_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31400 + * @tc.name : HksRsaSha1WithRsaPssMt31400 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_31400_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31500 + * @tc.name : HksRsaSha1WithRsaPssMt31500 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_31500_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31600 + * @tc.name : HksRsaSha1WithRsaPssMt31600 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_31600_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31700 + * @tc.name : HksRsaSha1WithRsaPssMt31700 + * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_31700_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31800 + * @tc.name : HksRsaSha1WithRsaPssMt31800 + * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_31800_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt31900 + * @tc.name : HksRsaSha1WithRsaPssMt31900 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_31900_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32000 + * @tc.name : HksRsaSha1WithRsaPssMt32000 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_32000_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32100 + * @tc.name : HksRsaSha1WithRsaPssMt32100 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_32100_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32200 + * @tc.name : HksRsaSha1WithRsaPssMt32200 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_32200_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32300 + * @tc.name : HksRsaSha1WithRsaPssMt32300 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_32300_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32400 + * @tc.name : HksRsaSha1WithRsaPssMt32400 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_32400_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32500 + * @tc.name : HksRsaSha1WithRsaPssMt32500 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_32500_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32600 + * @tc.name : HksRsaSha1WithRsaPssMt32600 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_32600_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32700 + * @tc.name : HksRsaSha1WithRsaPssMt32700 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_32700_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32800 + * @tc.name : HksRsaSha1WithRsaPssMt32800 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_32800_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt32900 + * @tc.name : HksRsaSha1WithRsaPssMt32900 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_32900_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33000 + * @tc.name : HksRsaSha1WithRsaPssMt33000 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_33000_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33100 + * @tc.name : HksRsaSha1WithRsaPssMt33100 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_33100_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33200 + * @tc.name : HksRsaSha1WithRsaPssMt33200 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_33200_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33300 + * @tc.name : HksRsaSha1WithRsaPssMt33300 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_33300_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33400 + * @tc.name : HksRsaSha1WithRsaPssMt33400 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_33400_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33500 + * @tc.name : HksRsaSha1WithRsaPssMt33500 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_33500_PARAMS); +} + +/** + * @tc.number : HksRsaSha1WithRsaPssMt33600 + * @tc.name : HksRsaSha1WithRsaPssMt33600 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_33600_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..aab3d3db9080c9cf07e003d842b6bbc2935190d8 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_33700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_33800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_33900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_34000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_34100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_34200_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_34300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_34400_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_34500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_34600_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_34700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_34800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_34900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_35000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_35100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_35200_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_35300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_35400_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_35500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_35600_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_35700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_35800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_35900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_36000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha224WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha224WithRsaMt33700 + * @tc.name : HksRsaSha224WithRsaMt33700 + * @tc.desc : Test huks sign (512/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_33700_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt33800 + * @tc.name : HksRsaSha224WithRsaMt33800 + * @tc.desc : Test huks sign (512/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_33800_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt33900 + * @tc.name : HksRsaSha224WithRsaMt33900 + * @tc.desc : Test huks Verify (512/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_33900_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34000 + * @tc.name : HksRsaSha224WithRsaMt34000 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_34000_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34100 + * @tc.name : HksRsaSha224WithRsaMt34100 + * @tc.desc : Test huks sign (768/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_34100_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34200 + * @tc.name : HksRsaSha224WithRsaMt34200 + * @tc.desc : Test huks sign (768/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_34200_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34300 + * @tc.name : HksRsaSha224WithRsaMt34300 + * @tc.desc : Test huks Verify (768/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_34300_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34400 + * @tc.name : HksRsaSha224WithRsaMt34400 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_34400_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34500 + * @tc.name : HksRsaSha224WithRsaMt34500 + * @tc.desc : Test huks sign (1024/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_34500_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34600 + * @tc.name : HksRsaSha224WithRsaMt34600 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_34600_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34700 + * @tc.name : HksRsaSha224WithRsaMt34700 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_34700_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34800 + * @tc.name : HksRsaSha224WithRsaMt34800 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_34800_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt34900 + * @tc.name : HksRsaSha224WithRsaMt34900 + * @tc.desc : Test huks sign (2048/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_34900_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35000 + * @tc.name : HksRsaSha224WithRsaMt35000 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_35000_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35100 + * @tc.name : HksRsaSha224WithRsaMt35100 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_35100_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35200 + * @tc.name : HksRsaSha224WithRsaMt35200 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_35200_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35300 + * @tc.name : HksRsaSha224WithRsaMt35300 + * @tc.desc : Test huks sign (3072/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_35300_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35400 + * @tc.name : HksRsaSha224WithRsaMt35400 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_35400_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35500 + * @tc.name : HksRsaSha224WithRsaMt35500 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_35500_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35600 + * @tc.name : HksRsaSha224WithRsaMt35600 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_35600_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35700 + * @tc.name : HksRsaSha224WithRsaMt35700 + * @tc.desc : Test huks sign (4096/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_35700_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35800 + * @tc.name : HksRsaSha224WithRsaMt35800 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_35800_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt35900 + * @tc.name : HksRsaSha224WithRsaMt35900 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_35900_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaMt36000 + * @tc.name : HksRsaSha224WithRsaMt36000 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt36000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_36000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..457fda34d46bb600a57ab4b8194311a9b2d4a8f9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_36100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_36200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_36300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_36400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_36500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_36600_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_36700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_36800_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_36900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_37000_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_37100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_37200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_37300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_37400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_37500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_37600_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_37700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_37800_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_37900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_38000_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_38100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_38200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_38300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_38400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha224WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36100 + * @tc.name : HksRsaSha224WithRsaPssMt36100 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_36100_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36200 + * @tc.name : HksRsaSha224WithRsaPssMt36200 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_36200_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36300 + * @tc.name : HksRsaSha224WithRsaPssMt36300 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_36300_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36400 + * @tc.name : HksRsaSha224WithRsaPssMt36400 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_36400_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36500 + * @tc.name : HksRsaSha224WithRsaPssMt36500 + * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_36500_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36600 + * @tc.name : HksRsaSha224WithRsaPssMt36600 + * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_36600_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36700 + * @tc.name : HksRsaSha224WithRsaPssMt36700 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_36700_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36800 + * @tc.name : HksRsaSha224WithRsaPssMt36800 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_36800_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt36900 + * @tc.name : HksRsaSha224WithRsaPssMt36900 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_36900_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37000 + * @tc.name : HksRsaSha224WithRsaPssMt37000 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_37000_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37100 + * @tc.name : HksRsaSha224WithRsaPssMt37100 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_37100_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37200 + * @tc.name : HksRsaSha224WithRsaPssMt37200 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_37200_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37300 + * @tc.name : HksRsaSha224WithRsaPssMt37300 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_37300_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37400 + * @tc.name : HksRsaSha224WithRsaPssMt37400 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_37400_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37500 + * @tc.name : HksRsaSha224WithRsaPssMt37500 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_37500_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37600 + * @tc.name : HksRsaSha224WithRsaPssMt37600 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_37600_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37700 + * @tc.name : HksRsaSha224WithRsaPssMt37700 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_37700_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37800 + * @tc.name : HksRsaSha224WithRsaPssMt37800 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_37800_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt37900 + * @tc.name : HksRsaSha224WithRsaPssMt37900 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_37900_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt38000 + * @tc.name : HksRsaSha224WithRsaPssMt38000 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_38000_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt38100 + * @tc.name : HksRsaSha224WithRsaPssMt38100 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_38100_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt38200 + * @tc.name : HksRsaSha224WithRsaPssMt38200 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_38200_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt38300 + * @tc.name : HksRsaSha224WithRsaPssMt38300 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_38300_PARAMS); +} + +/** + * @tc.number : HksRsaSha224WithRsaPssMt38400 + * @tc.name : HksRsaSha224WithRsaPssMt38400 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_38400_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..bda9fc258badc8bafe3fbf10fa2c51f64492546c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_38500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_38600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_38700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_38800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_38900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_39000_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_39100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_39200_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_39300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_39400_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_39500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_39600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_39700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_39800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_39900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_40000_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_40100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_40200_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_40300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_40400_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_40500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_40600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_40700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_40800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha256WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha256WithRsaMt38500 + * @tc.name : HksRsaSha256WithRsaMt38500 + * @tc.desc : Test huks sign (512/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_38500_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt38600 + * @tc.name : HksRsaSha256WithRsaMt38600 + * @tc.desc : Test huks sign (512/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_38600_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt38700 + * @tc.name : HksRsaSha256WithRsaMt38700 + * @tc.desc : Test huks Verify (512/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_38700_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt38800 + * @tc.name : HksRsaSha256WithRsaMt38800 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_38800_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt38900 + * @tc.name : HksRsaSha256WithRsaMt38900 + * @tc.desc : Test huks sign (768/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_38900_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39000 + * @tc.name : HksRsaSha256WithRsaMt39000 + * @tc.desc : Test huks sign (768/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_39000_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39100 + * @tc.name : HksRsaSha256WithRsaMt39100 + * @tc.desc : Test huks Verify (768/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_39100_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39200 + * @tc.name : HksRsaSha256WithRsaMt39200 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_39200_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39300 + * @tc.name : HksRsaSha256WithRsaMt39300 + * @tc.desc : Test huks sign (1024/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_39300_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39400 + * @tc.name : HksRsaSha256WithRsaMt39400 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_39400_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39500 + * @tc.name : HksRsaSha256WithRsaMt39500 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_39500_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39600 + * @tc.name : HksRsaSha256WithRsaMt39600 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_39600_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39700 + * @tc.name : HksRsaSha256WithRsaMt39700 + * @tc.desc : Test huks sign (2048/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_39700_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39800 + * @tc.name : HksRsaSha256WithRsaMt39800 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_39800_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt39900 + * @tc.name : HksRsaSha256WithRsaMt39900 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_39900_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40000 + * @tc.name : HksRsaSha256WithRsaMt40000 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_40000_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40100 + * @tc.name : HksRsaSha256WithRsaMt40100 + * @tc.desc : Test huks sign (3072/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_40100_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40200 + * @tc.name : HksRsaSha256WithRsaMt40200 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_40200_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40300 + * @tc.name : HksRsaSha256WithRsaMt40300 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_40300_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40400 + * @tc.name : HksRsaSha256WithRsaMt40400 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_40400_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40500 + * @tc.name : HksRsaSha256WithRsaMt40500 + * @tc.desc : Test huks sign (4096/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_40500_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40600 + * @tc.name : HksRsaSha256WithRsaMt40600 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_40600_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40700 + * @tc.name : HksRsaSha256WithRsaMt40700 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_40700_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaMt40800 + * @tc.name : HksRsaSha256WithRsaMt40800 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_40800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..57d546e83959c1305f818846f36382f8cfd7c253 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_40900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_41000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_41100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_41200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_41300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_41400_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_41500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_41600_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_41700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_41800_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_41900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_42000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_42100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_42200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_42300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_42400_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_42500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_42600_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_42700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_42800_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_42900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_43000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_43100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_43200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha256WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha256WithRsaPssMt40900 + * @tc.name : HksRsaSha256WithRsaPssMt40900 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt40900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_40900_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41000 + * @tc.name : HksRsaSha256WithRsaPssMt41000 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_41000_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41100 + * @tc.name : HksRsaSha256WithRsaPssMt41100 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_41100_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41200 + * @tc.name : HksRsaSha256WithRsaPssMt41200 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_41200_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41300 + * @tc.name : HksRsaSha256WithRsaPssMt41300 + * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_41300_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41400 + * @tc.name : HksRsaSha256WithRsaPssMt41400 + * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_41400_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41500 + * @tc.name : HksRsaSha256WithRsaPssMt41500 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_41500_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41600 + * @tc.name : HksRsaSha256WithRsaPssMt41600 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_41600_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41700 + * @tc.name : HksRsaSha256WithRsaPssMt41700 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_41700_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41800 + * @tc.name : HksRsaSha256WithRsaPssMt41800 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_41800_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt41900 + * @tc.name : HksRsaSha256WithRsaPssMt41900 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_41900_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42000 + * @tc.name : HksRsaSha256WithRsaPssMt42000 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_42000_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42100 + * @tc.name : HksRsaSha256WithRsaPssMt42100 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_42100_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42200 + * @tc.name : HksRsaSha256WithRsaPssMt42200 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_42200_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42300 + * @tc.name : HksRsaSha256WithRsaPssMt42300 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_42300_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42400 + * @tc.name : HksRsaSha256WithRsaPssMt42400 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_42400_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42500 + * @tc.name : HksRsaSha256WithRsaPssMt42500 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_42500_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42600 + * @tc.name : HksRsaSha256WithRsaPssMt42600 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_42600_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42700 + * @tc.name : HksRsaSha256WithRsaPssMt42700 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_42700_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42800 + * @tc.name : HksRsaSha256WithRsaPssMt42800 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_42800_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt42900 + * @tc.name : HksRsaSha256WithRsaPssMt42900 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_42900_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt43000 + * @tc.name : HksRsaSha256WithRsaPssMt43000 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_43000_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt43100 + * @tc.name : HksRsaSha256WithRsaPssMt43100 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_43100_PARAMS); +} + +/** + * @tc.number : HksRsaSha256WithRsaPssMt43200 + * @tc.name : HksRsaSha256WithRsaPssMt43200 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_43200_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..997fa0c93e398ae554e3f70988906cd4d4a42311 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp @@ -0,0 +1,791 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_43300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const SignServiceCaseParams HKS_RSA_MT_43400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const VerifyLocalCaseParams HKS_RSA_MT_43500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_43600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_43700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_43800_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_43900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_44000_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_44100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_44200_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_44300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_44400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_44500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_44600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_44700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_44800_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_44900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_45000_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_45100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_45200_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_45300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_45400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_45500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_45600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha384WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha384WithRsaMt43300 + * @tc.name : HksRsaSha384WithRsaMt43300 + * @tc.desc : Test huks sign (512/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_43300_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43400 + * @tc.name : HksRsaSha384WithRsaMt43400 + * @tc.desc : Test huks sign (512/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_43400_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43500 + * @tc.name : HksRsaSha384WithRsaMt43500 + * @tc.desc : Test huks Verify (512/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_43500_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43600 + * @tc.name : HksRsaSha384WithRsaMt43600 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_43600_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43700 + * @tc.name : HksRsaSha384WithRsaMt43700 + * @tc.desc : Test huks sign (768/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_43700_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43800 + * @tc.name : HksRsaSha384WithRsaMt43800 + * @tc.desc : Test huks sign (768/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_43800_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt43900 + * @tc.name : HksRsaSha384WithRsaMt43900 + * @tc.desc : Test huks Verify (768/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_43900_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44000 + * @tc.name : HksRsaSha384WithRsaMt44000 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_44000_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44100 + * @tc.name : HksRsaSha384WithRsaMt44100 + * @tc.desc : Test huks sign (1024/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_44100_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44200 + * @tc.name : HksRsaSha384WithRsaMt44200 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_44200_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44300 + * @tc.name : HksRsaSha384WithRsaMt44300 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_44300_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44400 + * @tc.name : HksRsaSha384WithRsaMt44400 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_44400_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44500 + * @tc.name : HksRsaSha384WithRsaMt44500 + * @tc.desc : Test huks sign (2048/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_44500_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44600 + * @tc.name : HksRsaSha384WithRsaMt44600 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_44600_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44700 + * @tc.name : HksRsaSha384WithRsaMt44700 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_44700_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44800 + * @tc.name : HksRsaSha384WithRsaMt44800 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_44800_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt44900 + * @tc.name : HksRsaSha384WithRsaMt44900 + * @tc.desc : Test huks sign (3072/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_44900_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45000 + * @tc.name : HksRsaSha384WithRsaMt45000 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_45000_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45100 + * @tc.name : HksRsaSha384WithRsaMt45100 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_45100_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45200 + * @tc.name : HksRsaSha384WithRsaMt45200 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_45200_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45300 + * @tc.name : HksRsaSha384WithRsaMt45300 + * @tc.desc : Test huks sign (4096/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_45300_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45400 + * @tc.name : HksRsaSha384WithRsaMt45400 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_45400_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45500 + * @tc.name : HksRsaSha384WithRsaMt45500 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_45500_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaMt45600 + * @tc.name : HksRsaSha384WithRsaMt45600 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_45600_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..d7a3c518e9b27ad6360995ab17d5e036fa2f0b01 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp @@ -0,0 +1,791 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_45700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const SignServiceCaseParams HKS_RSA_MT_45800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const VerifyLocalCaseParams HKS_RSA_MT_45900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_46000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_46100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_46200_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_46300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_46400_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_46500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_46600_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_46700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_46800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_46900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_47000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_47100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_47200_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_47300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_47400_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_47500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_47600_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_47700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_47800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_47900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_48000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha384WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha384WithRsaPssMt45700 + * @tc.name : HksRsaSha384WithRsaPssMt45700 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_45700_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt45800 + * @tc.name : HksRsaSha384WithRsaPssMt45800 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_45800_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt45900 + * @tc.name : HksRsaSha384WithRsaPssMt45900 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_45900_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46000 + * @tc.name : HksRsaSha384WithRsaPssMt46000 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_46000_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46100 + * @tc.name : HksRsaSha384WithRsaPssMt46100 + * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_46100_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46200 + * @tc.name : HksRsaSha384WithRsaPssMt46200 + * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_46200_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46300 + * @tc.name : HksRsaSha384WithRsaPssMt46300 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_46300_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46400 + * @tc.name : HksRsaSha384WithRsaPssMt46400 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_46400_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46500 + * @tc.name : HksRsaSha384WithRsaPssMt46500 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_46500_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46600 + * @tc.name : HksRsaSha384WithRsaPssMt46600 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_46600_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46700 + * @tc.name : HksRsaSha384WithRsaPssMt46700 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_46700_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46800 + * @tc.name : HksRsaSha384WithRsaPssMt46800 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_46800_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt46900 + * @tc.name : HksRsaSha384WithRsaPssMt46900 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_46900_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47000 + * @tc.name : HksRsaSha384WithRsaPssMt47000 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_47000_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47100 + * @tc.name : HksRsaSha384WithRsaPssMt47100 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_47100_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47200 + * @tc.name : HksRsaSha384WithRsaPssMt47200 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_47200_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47300 + * @tc.name : HksRsaSha384WithRsaPssMt47300 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_47300_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47400 + * @tc.name : HksRsaSha384WithRsaPssMt47400 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_47400_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47500 + * @tc.name : HksRsaSha384WithRsaPssMt47500 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_47500_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47600 + * @tc.name : HksRsaSha384WithRsaPssMt47600 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_47600_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47700 + * @tc.name : HksRsaSha384WithRsaPssMt47700 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_47700_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47800 + * @tc.name : HksRsaSha384WithRsaPssMt47800 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_47800_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt47900 + * @tc.name : HksRsaSha384WithRsaPssMt47900 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_47900_PARAMS); +} + +/** + * @tc.number : HksRsaSha384WithRsaPssMt48000 + * @tc.name : HksRsaSha384WithRsaPssMt48000 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt48000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_48000_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..632d589f6086e4b5642f488de0d709869fcfed88 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp @@ -0,0 +1,791 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_48100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const SignServiceCaseParams HKS_RSA_MT_48200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const VerifyLocalCaseParams HKS_RSA_MT_48300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_48400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_48500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_48600_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_48700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_48800_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_48900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_49000_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_49100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_49200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_49300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_49400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_49500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_49600_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_49700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_49800_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_49900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_50000_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_50100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_50200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_50300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_50400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha512WithRsaMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha512WithRsaMt48100 + * @tc.name : HksRsaSha512WithRsaMt48100 + * @tc.desc : Test huks sign (512/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_48100_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48200 + * @tc.name : HksRsaSha512WithRsaMt48200 + * @tc.desc : Test huks sign (512/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_48200_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48300 + * @tc.name : HksRsaSha512WithRsaMt48300 + * @tc.desc : Test huks Verify (512/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_48300_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48400 + * @tc.name : HksRsaSha512WithRsaMt48400 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_48400_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48500 + * @tc.name : HksRsaSha512WithRsaMt48500 + * @tc.desc : Test huks sign (768/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_48500_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48600 + * @tc.name : HksRsaSha512WithRsaMt48600 + * @tc.desc : Test huks sign (768/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_48600_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48700 + * @tc.name : HksRsaSha512WithRsaMt48700 + * @tc.desc : Test huks Verify (768/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_48700_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48800 + * @tc.name : HksRsaSha512WithRsaMt48800 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_48800_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt48900 + * @tc.name : HksRsaSha512WithRsaMt48900 + * @tc.desc : Test huks sign (1024/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_48900_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49000 + * @tc.name : HksRsaSha512WithRsaMt49000 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_49000_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49100 + * @tc.name : HksRsaSha512WithRsaMt49100 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_49100_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49200 + * @tc.name : HksRsaSha512WithRsaMt49200 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_49200_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49300 + * @tc.name : HksRsaSha512WithRsaMt49300 + * @tc.desc : Test huks sign (2048/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_49300_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49400 + * @tc.name : HksRsaSha512WithRsaMt49400 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_49400_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49500 + * @tc.name : HksRsaSha512WithRsaMt49500 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_49500_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49600 + * @tc.name : HksRsaSha512WithRsaMt49600 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_49600_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49700 + * @tc.name : HksRsaSha512WithRsaMt49700 + * @tc.desc : Test huks sign (3072/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_49700_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49800 + * @tc.name : HksRsaSha512WithRsaMt49800 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_49800_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt49900 + * @tc.name : HksRsaSha512WithRsaMt49900 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_49900_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt50000 + * @tc.name : HksRsaSha512WithRsaMt50000 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_50000_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt50100 + * @tc.name : HksRsaSha512WithRsaMt50100 + * @tc.desc : Test huks sign (4096/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_50100_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt50200 + * @tc.name : HksRsaSha512WithRsaMt50200 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_50200_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt50300 + * @tc.name : HksRsaSha512WithRsaMt50300 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_50300_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaMt50400 + * @tc.name : HksRsaSha512WithRsaMt50400 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_50400_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..86b0ad4b26323914f657aa90995b816c731f6c1e --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp @@ -0,0 +1,799 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; + +const SignLocalCaseParams HKS_RSA_MT_50500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const SignServiceCaseParams HKS_RSA_MT_50600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const VerifyLocalCaseParams HKS_RSA_MT_50700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_50800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_50900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const SignServiceCaseParams HKS_RSA_MT_51000_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const VerifyLocalCaseParams HKS_RSA_MT_51100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_51200_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_51300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_51400_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_51500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_51600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_51700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_51800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_51900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_52000_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_52100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_52200_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_52300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_52400_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignLocalCaseParams HKS_RSA_MT_52500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const SignServiceCaseParams HKS_RSA_MT_52600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyLocalCaseParams HKS_RSA_MT_52700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const VerifyServiceCaseParams HKS_RSA_MT_52800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaSha512WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaSha512WithRsaPssMt50500 + * @tc.name : HksRsaSha512WithRsaPssMt50500 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_50500_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt50600 + * @tc.name : HksRsaSha512WithRsaPssMt50600 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_50600_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt50700 + * @tc.name : HksRsaSha512WithRsaPssMt50700 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_50700_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt50800 + * @tc.name : HksRsaSha512WithRsaPssMt50800 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_50800_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt50900 + * @tc.name : HksRsaSha512WithRsaPssMt50900 + * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_50900_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51000 + * @tc.name : HksRsaSha512WithRsaPssMt51000 + * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_51000_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51100 + * @tc.name : HksRsaSha512WithRsaPssMt51100 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51100, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_51100_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51200 + * @tc.name : HksRsaSha512WithRsaPssMt51200 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51200, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_51200_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51300 + * @tc.name : HksRsaSha512WithRsaPssMt51300 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_51300_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51400 + * @tc.name : HksRsaSha512WithRsaPssMt51400 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_51400_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51500 + * @tc.name : HksRsaSha512WithRsaPssMt51500 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51500, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_51500_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51600 + * @tc.name : HksRsaSha512WithRsaPssMt51600 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51600, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_51600_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51700 + * @tc.name : HksRsaSha512WithRsaPssMt51700 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_51700_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51800 + * @tc.name : HksRsaSha512WithRsaPssMt51800 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_51800_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt51900 + * @tc.name : HksRsaSha512WithRsaPssMt51900 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51900, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_51900_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52000 + * @tc.name : HksRsaSha512WithRsaPssMt52000 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52000, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_52000_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52100 + * @tc.name : HksRsaSha512WithRsaPssMt52100 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_52100_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52200 + * @tc.name : HksRsaSha512WithRsaPssMt52200 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_52200_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52300 + * @tc.name : HksRsaSha512WithRsaPssMt52300 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52300, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_52300_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52400 + * @tc.name : HksRsaSha512WithRsaPssMt52400 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52400, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_52400_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52500 + * @tc.name : HksRsaSha512WithRsaPssMt52500 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_52500_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52600 + * @tc.name : HksRsaSha512WithRsaPssMt52600 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_52600_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52700 + * @tc.name : HksRsaSha512WithRsaPssMt52700 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52700, TestSize.Level1) +{ + VerifyLocalTestCase(HKS_RSA_MT_52700_PARAMS); +} + +/** + * @tc.number : HksRsaSha512WithRsaPssMt52800 + * @tc.name : HksRsaSha512WithRsaPssMt52800 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52800, TestSize.Level1) +{ + VerifyServiceTestCase(HKS_RSA_MT_52800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..d5fc643826f3ebd481c7855f024df2d9a246416b --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c @@ -0,0 +1,331 @@ +/* + * Copyright (C) 2021 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 "openssl_aes_helper.h" + +#include + +#define BIT_NUM_OF_UINT8 8 +#define HKS_AE_TAG_LEN 16 + +int32_t GenerateAesKey(const int keyLen, struct HksBlob *randomKey) +{ + uint32_t keySize = keyLen / BIT_NUM_OF_UINT8; + uint8_t *Key = (uint8_t *)malloc(keySize); + do { + if (RAND_bytes(Key, keySize) != 1) { + free(Key); + return HKS_FAILURE; + } + randomKey->size = keySize; + if (memcpy_s(randomKey->data, randomKey->size, Key, keySize) != 0) { + free(Key); + return HKS_FAILURE; + } + } while (0); + + free(Key); + return HKS_SUCCESS; +} + +static const EVP_CIPHER *AesCBCCrypt(uint32_t keyLen) +{ + if (keyLen == HKS_AES_KEY_SIZE_128) { + return EVP_aes_128_cbc(); + } else if (keyLen == HKS_AES_KEY_SIZE_192) { + return EVP_aes_192_cbc(); + } else if (keyLen == HKS_AES_KEY_SIZE_256) { + return EVP_aes_256_cbc(); + } + return NULL; +} + +static const EVP_CIPHER *AesECBCrypt(uint32_t keyLen) +{ + if (keyLen == HKS_AES_KEY_SIZE_128) { + return EVP_aes_128_ecb(); + } else if (keyLen == HKS_AES_KEY_SIZE_192) { + return EVP_aes_192_ecb(); + } else if (keyLen == HKS_AES_KEY_SIZE_256) { + return EVP_aes_256_ecb(); + } + return NULL; +} + +static const EVP_CIPHER *AesCTRCrypt(uint32_t keyLen) +{ + if (keyLen == HKS_AES_KEY_SIZE_128) { + return EVP_aes_128_ctr(); + } else if (keyLen == HKS_AES_KEY_SIZE_192) { + return EVP_aes_192_ctr(); + } else if (keyLen == HKS_AES_KEY_SIZE_256) { + return EVP_aes_256_ctr(); + } + return NULL; +} + +static const EVP_CIPHER *AesGCMCrypt(uint32_t keyLen) +{ + if (keyLen == HKS_AES_KEY_SIZE_128) { + return EVP_aes_128_gcm(); + } else if (keyLen == HKS_AES_KEY_SIZE_192) { + return EVP_aes_192_gcm(); + } else if (keyLen == HKS_AES_KEY_SIZE_256) { + return EVP_aes_256_gcm(); + } + return NULL; +} + +static uint32_t AesInit(EVP_CIPHER_CTX **ctx, const EVP_CIPHER **ciper, uint32_t mode, uint32_t keyLen) +{ + if (mode == HKS_MODE_GCM) { + *ciper = AesGCMCrypt(keyLen); + } else if (mode == HKS_MODE_CBC) { + *ciper = AesCBCCrypt(keyLen); + } else if (mode == HKS_MODE_ECB) { + *ciper = AesECBCrypt(keyLen); + } else if (mode == HKS_MODE_CTR) { + *ciper = AesCTRCrypt(keyLen); + } + + *ctx = EVP_CIPHER_CTX_new(); + if (*ctx == NULL) { + return HKS_FAILURE; + } + return HKS_SUCCESS; +} + +int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey) +{ + struct HksParam *mode = NULL; + HksGetParam(paramSetIn, HKS_TAG_BLOCK_MODE, &mode); + struct HksParam *keyLen = NULL; + HksGetParam(paramSetIn, HKS_TAG_KEY_SIZE, &keyLen); + struct HksParam *padding = NULL; + HksGetParam(paramSetIn, HKS_TAG_PADDING, &padding); + struct HksParam *iv = NULL; + HksGetParam(paramSetIn, HKS_TAG_IV, &iv); + + const EVP_CIPHER *ciper = NULL; + EVP_CIPHER_CTX *ctx = NULL; + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + int ret = 1; + if (padding->uint32Param == HKS_PADDING_PKCS7) { + ret = EVP_CIPHER_CTX_set_padding(ctx, 1); + } else if (padding->uint32Param == HKS_PADDING_NONE) { + ret = EVP_CIPHER_CTX_set_padding(ctx, 0); + } + if (ret != 1) { + EVP_CIPHER_CTX_free(ctx); + return ret; + } + + int outLen = 0; + if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size = outLen; + if (EVP_EncryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size += outLen; + EVP_CIPHER_CTX_free(ctx); + return HKS_SUCCESS; +} + +int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey) +{ + struct HksParam *mode = NULL; + HksGetParam(paramSetIn, HKS_TAG_BLOCK_MODE, &mode); + struct HksParam *keyLen = NULL; + HksGetParam(paramSetIn, HKS_TAG_KEY_SIZE, &keyLen); + struct HksParam *padding = NULL; + HksGetParam(paramSetIn, HKS_TAG_PADDING, &padding); + struct HksParam *iv = NULL; + HksGetParam(paramSetIn, HKS_TAG_IV, &iv); + + const EVP_CIPHER *ciper = NULL; + EVP_CIPHER_CTX *ctx = NULL; + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + int ret = 1; + if (padding->uint32Param == HKS_PADDING_PKCS7) { + ret = EVP_CIPHER_CTX_set_padding(ctx, 1); + } else if (padding->uint32Param == HKS_PADDING_NONE) { + ret = EVP_CIPHER_CTX_set_padding(ctx, 0); + } + if (ret != 1) { + EVP_CIPHER_CTX_free(ctx); + return ret; + } + + int outLen = 0; + if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size = outLen; + if (EVP_DecryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size += outLen; + EVP_CIPHER_CTX_free(ctx); + return HKS_SUCCESS; +} + +int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey, const struct HksBlob *tagAead) +{ + struct HksParam *mode = NULL; + HksGetParam(paramSetIn, HKS_TAG_BLOCK_MODE, &mode); + struct HksParam *keyLen = NULL; + HksGetParam(paramSetIn, HKS_TAG_KEY_SIZE, &keyLen); + struct HksParam *iv = NULL; + HksGetParam(paramSetIn, HKS_TAG_NONCE, &iv); + struct HksParam *aad = NULL; + HksGetParam(paramSetIn, HKS_TAG_ASSOCIATED_DATA, &aad); + + const EVP_CIPHER *ciper = NULL; + EVP_CIPHER_CTX *ctx = NULL; + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + int outLen = 0; + if (EVP_EncryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size = outLen; + if (EVP_EncryptFinal_ex(ctx, outData->data, &outLen) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, HKS_AE_TAG_LEN, tagAead->data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + EVP_CIPHER_CTX_free(ctx); + return HKS_SUCCESS; +} + +int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, + const struct HksBlob *randomKey, const struct HksBlob *tagDec) +{ + struct HksParam *mode = NULL; + HksGetParam(paramSetIn, HKS_TAG_BLOCK_MODE, &mode); + struct HksParam *keyLen = NULL; + HksGetParam(paramSetIn, HKS_TAG_KEY_SIZE, &keyLen); + struct HksParam *iv = NULL; + HksGetParam(paramSetIn, HKS_TAG_NONCE, &iv); + struct HksParam *aad = NULL; + HksGetParam(paramSetIn, HKS_TAG_ASSOCIATED_DATA, &aad); + + const EVP_CIPHER *ciper = NULL; + EVP_CIPHER_CTX *ctx = NULL; + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + + int outLen = 0; + if (EVP_DecryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + outData->size = outLen; + + if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tagDec->size, tagDec->data) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + if (EVP_DecryptFinal_ex(ctx, outData->data, &outLen) != 1) { + EVP_CIPHER_CTX_free(ctx); + return HKS_FAILURE; + } + EVP_CIPHER_CTX_free(ctx); + return HKS_SUCCESS; +} diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..cfa4fab2b87b3106e4561a5148e7b1f52928fe82 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c @@ -0,0 +1,281 @@ +/* + * Copyright (C) 2021 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 "openssl_dh_helper.h" + +#include +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_mem.h" + +static int32_t DhGetNid(uint32_t keySize, int *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return DH_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return DH_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return DH_SUCCESS; + default: + return DH_FAILED; + } +} + +static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct HksBlob *key) +{ + const BIGNUM *pubKey = NULL; + const BIGNUM *privKey = NULL; + DH_get0_key(dh, &pubKey, &privKey); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + BN_num_bytes(pubKey) + BN_num_bytes(privKey); + uint8_t *rawMaterial = (uint8_t *)malloc(rawMaterialLen); + if (rawMaterial == NULL) { + return DH_FAILED; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = BN_num_bytes(pubKey); + keyMaterial->priKeySize = BN_num_bytes(privKey); + keyMaterial->reserved = 0; + + uint32_t offset = sizeof(struct KeyMaterialDh); + BN_bn2bin(pubKey, rawMaterial + offset); + offset += keyMaterial->pubKeySize; + BN_bn2bin(privKey, rawMaterial + offset); + offset += keyMaterial->priKeySize; + + key->size = rawMaterialLen; + if (memcpy_s(key->data, key->size, rawMaterial, rawMaterialLen) != 0) { + free(rawMaterial); + return DH_FAILED; + } + + free(rawMaterial); + return DH_SUCCESS; +} + +int32_t DhGenerateKey(const int keyLen, struct HksBlob *key) +{ + int32_t ret; + int nid = 0; + ret = DhGetNid(keyLen, &nid); + if (ret != DH_SUCCESS) { + return ret; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + return DH_FAILED; + } + if (DH_generate_key(dh) != 1) { + DH_free(dh); + return DH_FAILED; + } + + ret = DhSaveKeyMaterial(dh, keyLen, key); + + DH_free(dh); + + return ret; +} + +static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + int32_t ret = DH_SUCCESS; + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + if (key->size != sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize + keyMaterial->priKeySize) { + return NULL; + } + + int nid = 0; + ret = DhGetNid(keyMaterial->keySize, &nid); + if (ret != DH_SUCCESS) { + return NULL; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + return NULL; + } + + uint32_t offset = sizeof(struct KeyMaterialDh); + BIGNUM *pubKey = BN_bin2bn(key->data + offset, keyMaterial->pubKeySize, NULL); + offset += keyMaterial->pubKeySize; + BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL); + + if (DH_set0_key(dh, pubKey, privKey) != 1) { + if (pubKey != NULL) { + BN_free(pubKey); + } + if (privKey != NULL) { + BN_free(privKey); + } + DH_free(dh); + return NULL; + } + + return dh; +} + +int32_t DhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) +{ + int32_t ret; + + if ((uint32_t)HKS_KEY_BYTES(keyLen) > sharedKey->size) { + return DH_FAILED; + } + + DH *dh = InitDhStruct(nativeKey, true); + if (dh == NULL) { + return DH_FAILED; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + DH_free(dh); + return DH_FAILED; + } + + uint8_t computeKey[DH_size(dh)]; + + if (DH_compute_key_padded(computeKey, pub, dh) <= 0) { + BN_free(pub); + DH_free(dh); + return DH_FAILED; + } + + if (HKS_KEY_BYTES(keyLen) > DH_size(dh)) { + ret = DH_FAILED; + } else { + (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(keyLen)); + sharedKey->size = DH_size(dh); + ret = DH_SUCCESS; + } + + BN_free(pub); + DH_free(dh); + return ret; +} + +int32_t DhGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return DH_FAILED; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return DH_FAILED; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return DH_SUCCESS; +} + +int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + if (x509Key == NULL || x509Key->data == NULL || x509Key->size == 0 || publicKey == NULL) { + return DH_FAILED; + } + + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return DH_FAILED; + } + + DH *dh = EVP_PKEY_get0_DH(pkey); + if (dh == NULL) { + EVP_PKEY_free(pkey); + return DH_FAILED; + } + + const BIGNUM *pubKey = DH_get0_pub_key(dh); + uint32_t dhpubKeySize = BN_num_bytes(pubKey); + + uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + dhpubKeySize); + if (keyBuffer == NULL) { + EVP_PKEY_free(pkey); + return DH_FAILED; + } + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = DH_bits(dh); + keyMaterial->pubKeySize = dhpubKeySize; + keyMaterial->priKeySize = 0; + keyMaterial->reserved = 0; + + BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); + + publicKey->size = sizeof(struct KeyMaterialDh) + dhpubKeySize; + if (memcpy_s(publicKey->data, publicKey->size, keyBuffer, sizeof(struct KeyMaterialDh) + dhpubKeySize) != 0) { + EVP_PKEY_free(pkey); + free(keyBuffer); + return DH_FAILED; + } + + free(keyBuffer); + EVP_PKEY_free(pkey); + return DH_SUCCESS; +} + +int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) +{ + DH *dh = InitDhStruct(key, true); + if (dh == NULL) { + return DH_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DH_free(dh); + return DH_FAILED; + } + + if (EVP_PKEY_assign_DH(pkey, dh) != 1) { + DH_free(dh); + EVP_PKEY_free(pkey); + return DH_FAILED; + } + + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + if (tmp == NULL) { + EVP_PKEY_free(pkey); + return DH_FAILED; + } + if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) { + EVP_PKEY_free(pkey); + free(tmp); + return DH_FAILED; + } + + EVP_PKEY_free(pkey); + free(tmp); + return DH_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..7da92a9531a1c789f478c7c584cc6e42d74c427f --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c @@ -0,0 +1,370 @@ +/* + * Copyright (C) 2021 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 "openssl_dsa_helper.h" + +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_common_check.h" + +#define OPENSSL_KEY_BLOCK 8 +#define OPENSSL_DSA_MIN_KEY_LEN 64 +#define OPENSSL_DSA_KEY_LEN_DIVID (2048 / HKS_BITS_PER_BYTE) + +EVP_PKEY *GenerateDsaKey(const uint32_t keySize) +{ + DSA *dsa = DSA_new(); + if (dsa == NULL) { + return NULL; + } + if (DSA_generate_parameters_ex(dsa, keySize, NULL, 0, NULL, NULL, NULL) != 1) { + DSA_free(dsa); + return NULL; + } + if (DSA_generate_key(dsa) != 1) { + DSA_free(dsa); + return NULL; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DSA_free(dsa); + return NULL; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return NULL; + } + + return pkey; +} + +static BIGNUM *BinToBN(uint8_t *data, uint32_t length) +{ + uint8_t buff[length]; + if (memcpy_s(buff, sizeof(buff), data, length) != 0) { + return NULL; + } + return BN_bin2bn(buff, length, NULL); +} + +static void FreeBN(BIGNUM *bn) +{ + if (bn != NULL) { + BN_free(bn); + } +} + +static DSA *InitDsa(struct HksBlob *key, const bool needPrivateExponent) +{ + const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data); + + uint32_t offset = sizeof(*keyMaterial); + BIGNUM *x = NULL; + BIGNUM *y = NULL; + BIGNUM *p = NULL; + BIGNUM *q = NULL; + BIGNUM *g = NULL; + + if (needPrivateExponent) { + x = BinToBN(key->data + offset, keyMaterial->xSize); + offset += keyMaterial->xSize; + } + + y = BinToBN(key->data + offset, keyMaterial->ySize); + offset += keyMaterial->ySize; + + p = BinToBN(key->data + offset, keyMaterial->pSize); + offset += keyMaterial->pSize; + + q = BinToBN(key->data + offset, keyMaterial->qSize); + offset += keyMaterial->qSize; + + g = BinToBN(key->data + offset, keyMaterial->gSize); + + DSA *dsa = NULL; + do { + dsa = DSA_new(); + if (dsa == NULL) { + break; + } + + if (DSA_set0_key(dsa, y, x) != 1) { + DSA_free(dsa); + dsa = NULL; + break; + } + + if (DSA_set0_pqg(dsa, p, q, g) != 1) { + DSA_free(dsa); + dsa = NULL; + break; + } + } while (0); + + if (dsa == NULL) { + FreeBN(x); + FreeBN(y); + FreeBN(p); + FreeBN(q); + FreeBN(g); + } + + return dsa; +} + +static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType) +{ + switch (digestType) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +int32_t OpensslSignDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType) +{ + DSA *dsa = InitDsa(key, true); + if (dsa == NULL) { + return DSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DSA_free(dsa); + return DSA_FAILED; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return DSA_FAILED; + } + + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestSignInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + size_t signLen = signData->size; + if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + signData->size = signLen; + + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + + return DSA_SUCCESS; +} + +int32_t OpensslVerifyDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType) +{ + DSA *dsa = InitDsa(key, false); + if (dsa == NULL) { + return DSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DSA_free(dsa); + return DSA_FAILED; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return DSA_FAILED; + } + + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + + return DSA_SUCCESS; +} + +int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return DSA_FAILED; + } + + DSA *dsa = EVP_PKEY_get0_DSA(pkey); + if (dsa == NULL) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + int32_t ySize = BN_num_bytes(DSA_get0_pub_key(dsa)); + int32_t pSize = BN_num_bytes(DSA_get0_p(dsa)); + int32_t qSize = BN_num_bytes(DSA_get0_q(dsa)); + int32_t gSize = BN_num_bytes(DSA_get0_g(dsa)); + if ((ySize <= 0) || (pSize <= 0) || (qSize <= 0) || (gSize <= 0)) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)publicKey->data; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = (ySize + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE; + keyMaterial->xSize = 0; + keyMaterial->ySize = ySize; + keyMaterial->pSize = pSize; + keyMaterial->qSize = qSize; + keyMaterial->gSize = gSize; + + int32_t result = DSA_FAILED; + uint32_t offset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize; + do { + if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + offset) == 0)) { + break; + } + if (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + offset + ySize) == 0) { + break; + } + if (BN_bn2bin(DSA_get0_q(dsa), publicKey->data + offset + ySize + pSize) == 0) { + break; + } + if (BN_bn2bin(DSA_get0_g(dsa), publicKey->data + offset + ySize + pSize + qSize) == 0) { + break; + } + result = DSA_SUCCESS; + } while (0); + + EVP_PKEY_free(pkey); + return result; +} + +void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) +{ + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + if (tmp != NULL) { + (void)memcpy_s(x509Key->data, x509Key->size, tmp, length); + free(tmp); + } +} + +int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key) +{ + uint32_t opensslKeyByteLen = HKS_KEY_BYTES(keySize); + if (opensslKeyByteLen < OPENSSL_DSA_MIN_KEY_LEN) { + opensslKeyByteLen = OPENSSL_DSA_MIN_KEY_LEN; + } + uint32_t keyByteLen = (opensslKeyByteLen + OPENSSL_KEY_BLOCK - 1) / OPENSSL_KEY_BLOCK * OPENSSL_KEY_BLOCK; + + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)key->data; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = keyByteLen * HKS_BITS_PER_BYTE; + keyMaterial->xSize = (keyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + keyMaterial->ySize = keyByteLen; + keyMaterial->pSize = keyByteLen; + keyMaterial->qSize = (keyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + keyMaterial->gSize = keyByteLen; + + const BIGNUM *x = DSA_get0_priv_key(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *y = DSA_get0_pub_key(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *p = DSA_get0_p(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *q = DSA_get0_q(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *g = DSA_get0_g(EVP_PKEY_get0_DSA(pkey)); + + int32_t offset = sizeof(struct KeyMaterialDsa); + int32_t ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->xSize; + ret = BN_bn2bin(y, key->data + offset + (keyMaterial->ySize - BN_num_bytes(y))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->ySize; + ret = BN_bn2bin(p, key->data + offset + (keyMaterial->pSize - BN_num_bytes(p))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->pSize; + ret = BN_bn2bin(q, key->data + offset + (keyMaterial->qSize - BN_num_bytes(q))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->qSize; + ret = BN_bn2bin(g, key->data + offset + (keyMaterial->gSize - BN_num_bytes(g))); + if (ret <= 0) { + return DSA_FAILED; + } + return DSA_SUCCESS; +} diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..71701bdf43cd45b7489f5ed595d464a1d26f4531 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c @@ -0,0 +1,629 @@ +/* + * Copyright (C) 2021 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 "openssl_ecc_helper.h" + +#include +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_mem.h" + +static int32_t GetCurveId(uint32_t keyLen, int *nid) +{ + switch (keyLen) { + case HKS_ECC_KEY_SIZE_224: + *nid = NID_secp224r1; + break; + case HKS_ECC_KEY_SIZE_256: + *nid = NID_X9_62_prime256v1; + break; + case HKS_ECC_KEY_SIZE_384: + *nid = NID_secp384r1; + break; + case HKS_ECC_KEY_SIZE_521: + *nid = NID_secp521r1; + break; + default: + return ECC_FAILED; + } + + return ECC_SUCCESS; +} + +const EVP_MD *GetOpensslAlg(uint32_t alg) +{ + switch (alg) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +static int32_t TransEccKeyToKeyBlob( + const struct KeyMaterialEcc *keyMaterial, BIGNUM *pubX, BIGNUM *pubY, const BIGNUM *priv, uint8_t *rawMaterial) +{ + uint32_t offset = sizeof(struct KeyMaterialEcc); + if (BN_bn2binpad(pubX, rawMaterial + offset, keyMaterial->xSize) <= 0) { + return ECC_FAILED; + } + offset += keyMaterial->xSize; + + if (BN_bn2binpad(pubY, rawMaterial + offset, keyMaterial->ySize) <= 0) { + return ECC_FAILED; + } + offset += keyMaterial->ySize; + + if (BN_bn2binpad(priv, rawMaterial + offset, keyMaterial->zSize) <= 0) { + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keyLen, uint8_t **output, uint32_t *outputSize) +{ + uint32_t rawMaterialLen = sizeof(struct KeyMaterialEcc) + HKS_KEY_BYTES(keyLen) * ECC_KEYPAIR_CNT; + uint8_t *rawMaterial = (uint8_t *)malloc(rawMaterialLen); + if (rawMaterial == NULL) { + return ECC_FAILED; + } + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_ECC; + keyMaterial->keySize = keyLen; + keyMaterial->xSize = HKS_KEY_BYTES(keyLen); + keyMaterial->ySize = HKS_KEY_BYTES(keyLen); + keyMaterial->zSize = HKS_KEY_BYTES(keyLen); + BIGNUM *pubX = BN_new(); + BIGNUM *pubY = BN_new(); + + if ((pubX == NULL) || (pubY == NULL)) { + free(rawMaterial); + return ECC_FAILED; + } + + int32_t result = ECC_FAILED; + do { + const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); + if (ecGroup == NULL) { + break; + } + + if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) != 1) { + break; + } + + const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); + if (priv == NULL) { + break; + } + + if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) { + break; + } + + *outputSize = rawMaterialLen; + + if (memcpy_s(*output, *outputSize, rawMaterial, rawMaterialLen) != 0) { + break; + } + + result = ECC_SUCCESS; + } while (0); + + BN_free(pubX); + BN_free(pubY); + free(rawMaterial); + return ECC_SUCCESS; +} + +int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key) +{ + int curveId; + if (GetCurveId(keyLen, &curveId) != ECC_SUCCESS) { + return ECC_FAILED; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(curveId); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EC_KEY_generate_key(eccKey) <= 0) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + if (EccSaveKeyMaterial(eccKey, keyLen, &key->data, &key->size) != ECC_SUCCESS) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + EC_KEY_free(eccKey); + return ECC_SUCCESS; +} + +static int GetEccModules( + const uint8_t *key, uint32_t *keySize, uint32_t *publicXSize, uint32_t *publicYSize, uint32_t *privateXSize) +{ + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)key; + *keySize = keyMaterial->keySize; + *publicXSize = keyMaterial->xSize; + *publicYSize = keyMaterial->ySize; + *privateXSize = keyMaterial->zSize; + + return 0; +} + +static int32_t EccInitPublicKey(EC_KEY *eccKey, const uint8_t *keyPair, uint32_t xSize, uint32_t ySize) +{ + const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); + if (ecGroup == NULL) { + return ECC_FAILED; + } + + int32_t ret = ECC_FAILED; + uint32_t offset = sizeof(struct KeyMaterialEcc); + EC_POINT *pub = EC_POINT_new(ecGroup); + BIGNUM *pubX = BN_bin2bn(keyPair + offset, xSize, NULL); + offset += xSize; + BIGNUM *pubY = BN_bin2bn(keyPair + offset, ySize, NULL); + do { + if ((pubX == NULL) || (pubY == NULL) || (pub == NULL)) { + break; + } + + if (EC_POINT_set_affine_coordinates_GFp(ecGroup, pub, pubX, pubY, NULL) <= 0) { + break; + } + + if (EC_KEY_set_public_key(eccKey, pub) <= 0) { + break; + } + ret = ECC_SUCCESS; + } while (0); + + if (pubX != NULL) { + BN_free(pubX); + pubX = NULL; + } + + if (pubY != NULL) { + BN_free(pubY); + pubY = NULL; + } + + if (pub != NULL) { + EC_POINT_free(pub); + pub = NULL; + } + return ret; +} + +static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool sign) +{ + /* get ecc pubX,pubY,pri */ + uint8_t *keyPair = keyBlob->data; + uint32_t publicXSize; + uint32_t publicYSize; + uint32_t privateSize; + uint32_t keySize; + + if (GetEccModules(keyPair, &keySize, &publicXSize, &publicYSize, &privateSize) != 0) { + return NULL; + } + + int nid; + if (GetCurveId(keySize, &nid) != ECC_SUCCESS) { + return NULL; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); + if (eccKey == NULL) { + return NULL; + } + + if (EccInitPublicKey(eccKey, keyPair, publicXSize, publicYSize) != ECC_SUCCESS) { + EC_KEY_free(eccKey); + return NULL; + } + + if (sign) { + BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, privateSize, NULL); + if (pri == NULL) { + EC_KEY_free(eccKey); + return NULL; + } + if (EC_KEY_set_private_key(eccKey, pri) != 1) { + BN_free(pri); + EC_KEY_free(eccKey); + return NULL; + } + BN_clear_free(pri); + } + + return eccKey; +} + +static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign) +{ + const EVP_MD *md = GetOpensslAlg(digest); + + EC_KEY *eccKey = EccInitKey(mainKey, sign); + if (eccKey == NULL) { + return NULL; + } + + EVP_PKEY *key = EVP_PKEY_new(); + if (key == NULL) { + EC_KEY_free(eccKey); + return NULL; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) != 1) { + EC_KEY_free(eccKey); + EVP_PKEY_free(key); + return NULL; + } + + EVP_MD_CTX *ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + EVP_PKEY_free(key); + return NULL; + } + + if (sign) { + int32_t ret = EVP_DigestSignInit(ctx, NULL, md, NULL, key); + EVP_PKEY_free(key); + if (ret != 1) { + EVP_MD_CTX_free(ctx); + return NULL; + } + } else { + int ret = EVP_DigestVerifyInit(ctx, NULL, md, NULL, key); + EVP_PKEY_free(key); + if (ret != 1) { + EVP_MD_CTX_free(ctx); + return NULL; + } + } + return ctx; +} + +int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitEccMdCtx(key, digest, true); + if (ctx == NULL) { + return ECC_FAILED; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != 1) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + size_t req = 0; + + if (EVP_DigestSignFinal(ctx, NULL, &req) != 1) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &req) != 1) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + signature->size = req; + + EVP_MD_CTX_free(ctx); + return ECC_SUCCESS; +} + +int32_t EcdsaVerify( + const struct HksBlob *key, int digest, const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitEccMdCtx(key, digest, false); + if (ctx == NULL) { + return ECC_FAILED; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != 1) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != 1) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + EVP_MD_CTX_free(ctx); + return ECC_SUCCESS; +} + +int32_t GetEccPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)input->data; + + output->size = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + + struct KeyMaterialEcc *publickeyMaterial = (struct KeyMaterialEcc *)output->data; + publickeyMaterial->keyAlg = keyMaterial->keyAlg; + publickeyMaterial->keySize = keyMaterial->keySize; + publickeyMaterial->xSize = keyMaterial->xSize; + publickeyMaterial->ySize = keyMaterial->ySize; + publickeyMaterial->zSize = 0; + + if (memcpy_s(output->data + sizeof(struct KeyMaterialEcc), + output->size - sizeof(struct KeyMaterialEcc), + input->data + sizeof(struct KeyMaterialEcc), + keyMaterial->xSize + keyMaterial->ySize) != 0) { + return ECC_FAILED; + } + + return ECC_SUCCESS; +} + +static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) +{ + BIGNUM *x = BN_new(); + BIGNUM *y = BN_new(); + int32_t ret; + do { + ret = ECC_FAILED; + if (x == NULL || y == NULL) { + break; + } + + if (EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ecKey), EC_KEY_get0_public_key(ecKey), x, y, NULL) == + 0) { + break; + } + + int32_t xSize = BN_num_bytes(x); + int32_t ySize = BN_num_bytes(y); + if (xSize <= 0 || ySize <= 0) { + break; + } + + /* x and y in ECC algorithm is small, will never overflow. */ + uint32_t totalSize = xSize + ySize + sizeof(struct HksPubKeyInfo); + uint8_t *keyBuffer = HksMalloc(totalSize); + if (keyBuffer == NULL) { + break; + } + + struct HksPubKeyInfo *pubKeyInfo = (struct HksPubKeyInfo *)keyBuffer; + pubKeyInfo->keyAlg = HKS_ALG_ECC; + pubKeyInfo->keySize = EC_GROUP_order_bits(EC_KEY_get0_group(ecKey)); + pubKeyInfo->nOrXSize = xSize; + pubKeyInfo->eOrYSize = ySize; + if (BN_bn2bin(x, keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || + BN_bn2bin(y, keyBuffer + sizeof(struct HksPubKeyInfo) + xSize) == 0) { + HKS_FREE_PTR(keyBuffer); + break; + } + + ret = ECC_SUCCESS; + eccPublicKey->size = totalSize; + if (memcpy_s(eccPublicKey->data, eccPublicKey->size, keyBuffer, totalSize) != 0) { + HKS_FREE_PTR(keyBuffer); + break; + } + HKS_FREE_PTR(keyBuffer); + } while (0); + + SELF_FREE_PTR(x, BN_free); + SELF_FREE_PTR(y, BN_free); + return ret; +} + +int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + if (x509Key == NULL || x509Key->data == NULL || x509Key->size == 0 || publicKey == NULL) { + return ECC_FAILED; + } + + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return ECC_FAILED; + } + + EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey); + if (ecKey == NULL) { + EVP_PKEY_free(pkey); + return ECC_FAILED; + } + + if (EcKeyToPublicKey(ecKey, publicKey) != ECC_SUCCESS) { + EVP_PKEY_free(pkey); + return ECC_FAILED; + }; + + EVP_PKEY_free(pkey); + return ECC_SUCCESS; +} + +int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) +{ + uint8_t *keyPair = key->data; + uint32_t publicXSize; + uint32_t publicYSize; + uint32_t privateSize; + uint32_t keySize; + + if (GetEccModules(keyPair, &keySize, &publicXSize, &publicYSize, &privateSize) != 0) { + return ECC_FAILED; + } + + int nid; + if (GetCurveId(keySize, &nid) != ECC_SUCCESS) { + return ECC_FAILED; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EccInitPublicKey(eccKey, keyPair, publicXSize, publicYSize) != ECC_SUCCESS) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(pkey, eccKey) <= 0) { + EC_KEY_free(eccKey); + EVP_PKEY_free(pkey); + return ECC_FAILED; + } + + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + if (tmp == NULL) { + EVP_PKEY_free(pkey); + return ECC_FAILED; + } + + if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) { + EVP_PKEY_free(pkey); + free(tmp); + return ECC_FAILED; + } + + EVP_PKEY_free(pkey); + free(tmp); + return ECC_SUCCESS; +} + +int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) +{ + EC_KEY *eccKey = EccInitKey(nativeKey, true); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) +{ + EC_KEY *eccKey = EccInitKey(pubKey, false); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) +{ + if (EVP_PKEY_derive_init(ctx) != 1) { + return ECC_FAILED; + } + if (EVP_PKEY_derive_set_peer(ctx, peerKey) != 1) { + return ECC_FAILED; + } + size_t keyLen; + if (EVP_PKEY_derive(ctx, NULL, &keyLen) != 1) { + return ECC_FAILED; + } + sharedKey->size = keyLen; + + if (sharedKey->data == NULL) { + sharedKey->data = (uint8_t *)HksMalloc(keyLen); + if (sharedKey->data == NULL) { + return ECC_FAILED; + } + } + if (EVP_PKEY_derive(ctx, sharedKey->data, &keyLen) != 1) { + HksFree(sharedKey->data); + return ECC_FAILED; + } + sharedKey->size = keyLen; + + return ECC_SUCCESS; +} + +int32_t EcdhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) +{ + int32_t ret = ECC_FAILED; + EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *peerKey = EVP_PKEY_new(); + EVP_PKEY_CTX *ctx = NULL; + + do { + if ((peerKey == NULL) || (pKey == NULL)) { + break; + } + if (GetNativePKey(nativeKey, pKey) != ECC_SUCCESS) { + break; + } + + if (GetPeerKey(pubKey, peerKey) != ECC_SUCCESS) { + break; + } + + ctx = EVP_PKEY_CTX_new(pKey, NULL); + if (ctx == NULL) { + break; + } + + if (EcdhDerive(ctx, peerKey, sharedKey) != ECC_SUCCESS) { + break; + } + + ret = ECC_SUCCESS; + } while (0); + + if (ctx != NULL) { + EVP_PKEY_CTX_free(ctx); + } + if (peerKey != NULL) { + EVP_PKEY_free(peerKey); + } + if (pKey != NULL) { + EVP_PKEY_free(pKey); + } + + return ret; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..8dd44384f07a1611c7a850f5e907391e2ad64a65 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2021 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 "openssl_hmac_helper.h" + +int32_t HmacGenerateKey(int key_len, struct HksBlob *key) +{ + uint32_t keySizeByte = key_len / BIT_NUM_OF_UINT8; + + uint8_t *tmpKey = (uint8_t *)malloc(keySizeByte); + if (tmpKey == NULL) { + return HMAC_FAILED; + } + + if (RAND_bytes(tmpKey, keySizeByte) != 1) { + free(tmpKey); + return HMAC_FAILED; + } + + key->data = tmpKey; + key->size = keySizeByte; + + return HMAC_SUCCESS; +} + +static const EVP_MD *GetAlg(uint32_t alg) +{ + switch (alg) { + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +int32_t HmacHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) +{ + const EVP_MD *getDigestAlg = GetAlg(digestAlg); + if (getDigestAlg == NULL) { + return HMAC_FAILED; + } + if (HMAC(getDigestAlg, key->data, (int32_t)key->size, msg->data, msg->size, mac->data, &mac->size) == NULL) { + return HMAC_FAILED; + } + return HMAC_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c new file mode 100755 index 0000000000000000000000000000000000000000..d607bec2abe852e3f293059784b6591702366250 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c @@ -0,0 +1,415 @@ +/* + * Copyright (C) 2021 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 "openssl_rsa_helper.h" + +#include +#include + +#include "hks_crypto_hal.h" + +void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key) +{ + const uint32_t keyByteLen = keySize / BIT_NUM_OF_UINT8; + + struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)key->data; + keyMaterial->keyAlg = HKS_ALG_RSA; + keyMaterial->keySize = keySize; + keyMaterial->nSize = keyByteLen; + keyMaterial->eSize = keyByteLen; + keyMaterial->dSize = keyByteLen; + + uint8_t tmpBuff[keyByteLen]; + memset_s(tmpBuff, keyByteLen, 0x00, keyByteLen); + + uint32_t offset = sizeof(*keyMaterial); + if (BN_bn2binpad(RSA_get0_n(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->nSize, tmpBuff, keyMaterial->nSize); + } + + offset += keyMaterial->nSize; + if (BN_bn2binpad(RSA_get0_e(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->eSize, tmpBuff, keyMaterial->eSize); + } + + offset += keyMaterial->eSize; + if (BN_bn2binpad(RSA_get0_d(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->dSize, tmpBuff, keyMaterial->dSize); + } + key->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize; +} + +EVP_PKEY *GenerateRSAKey(const uint32_t keySize) +{ + BIGNUM *bne = BN_new(); + if (bne == NULL) { + return NULL; + } + BN_set_word(bne, RSA_F4); + + RSA *rsa = RSA_new(); + if (rsa == NULL) { + BN_free(bne); + return NULL; + } + + if (RSA_generate_key_ex(rsa, keySize, bne, NULL) != 1) { + RSA_free(rsa); + BN_free(bne); + return NULL; + } + BN_free(bne); + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + return NULL; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return NULL; + } + + return pkey; +} + +void OpensslGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) +{ + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + if (tmp != NULL) { + (void)memcpy_s(x509Key->data, x509Key->size, tmp, length); + free(tmp); + } +} + +int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return RSA_FAILED; + } + RSA *rsa = EVP_PKEY_get0_RSA(pkey); + if (rsa == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + int32_t nSize = BN_num_bytes(RSA_get0_n(rsa)); + int32_t eSize = BN_num_bytes(RSA_get0_e(rsa)); + if ((nSize <= 0) || (eSize <= 0)) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + struct HksPubKeyInfo *pubKeyInfo = (struct HksPubKeyInfo *)publicKey->data; + pubKeyInfo->keyAlg = HKS_ALG_RSA; + pubKeyInfo->keySize = RSA_size(rsa) * BIT_NUM_OF_UINT8; + pubKeyInfo->nOrXSize = nSize; + pubKeyInfo->eOrYSize = eSize; + if ((BN_bn2bin(RSA_get0_n(rsa), publicKey->data + sizeof(struct HksPubKeyInfo)) == 0) || + (BN_bn2bin(RSA_get0_e(rsa), publicKey->data + sizeof(struct HksPubKeyInfo) + nSize) == 0)) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + EVP_PKEY_free(pkey); + return RSA_SUCCESS; +} + +static RSA *InitRsa(struct HksBlob *key, const bool needPrivateExponent) +{ + const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); + uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + + BIGNUM *n = NULL; + BIGNUM *e = NULL; + BIGNUM *d = NULL; + + uint32_t offset = sizeof(*keyMaterial); + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize) == 0) { + n = BN_bin2bn(buff, keyMaterial->nSize, NULL); + } + offset += keyMaterial->nSize; + + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize) == 0) { + e = BN_bin2bn(buff, keyMaterial->eSize, NULL); + } + offset += keyMaterial->eSize; + + if (needPrivateExponent) { + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize) == 0) { + d = BN_bin2bn(buff, keyMaterial->dSize, NULL); + } + } + + RSA *rsa = RSA_new(); + if (rsa != NULL) { + if (RSA_set0_key(rsa, n, e, d) != 1) { + RSA_free(rsa); + rsa = NULL; + } + } + + if (rsa == NULL) { + if (n != NULL) { + BN_free(n); + } + if (e != NULL) { + BN_free(e); + } + if (d != NULL) { + BN_free(d); + } + } + + return rsa; +} + +static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType) +{ + switch (digestType) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, false); + if (rsa == NULL) { + return RSA_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return RSA_FAILED; + } + EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL); + if (ectx == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if ((EVP_PKEY_encrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if (padding == RSA_PKCS1_OAEP_PADDING) { + const EVP_MD *md = GetOpensslDigestType(digestType); + if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + } + size_t outLen = outData->size; + if (EVP_PKEY_encrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + outData->size = outLen; + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_SUCCESS; +} + +int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, true); + if (rsa == NULL) { + return RSA_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return RSA_FAILED; + } + EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL); + if (ectx == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if ((EVP_PKEY_decrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if (padding == RSA_PKCS1_OAEP_PADDING) { + const EVP_MD *md = GetOpensslDigestType(digestType); + if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + } + size_t outLen = outData->size; + if (EVP_PKEY_decrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + outData->size = outLen; + + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + + return RSA_SUCCESS; +} + +int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, true); + if (rsa == NULL) { + return RSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return RSA_FAILED; + } + + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestSignInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + if (padding == RSA_PKCS1_PSS_PADDING) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + } + + if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + size_t signLen = signData->size; + if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + signData->size = signLen; + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return RSA_SUCCESS; +} + +int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, false); + if (rsa == NULL) { + return RSA_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return RSA_FAILED; + } + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + if (padding == RSA_PKCS1_PSS_PADDING) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + } + + if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return RSA_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp index f124d62abcac7ed5abfc4295b99e4c9862125cf4..33ab6008434ef1400badbb2ade43d69498ddf0a5 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp @@ -55,7 +55,7 @@ void HksAesTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree() == 0); } @@ -65,7 +65,7 @@ HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree1() == 0); } @@ -75,7 +75,7 @@ HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree2() == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp index 15c49f694f4d40203ea82f74e868cb26b7c45933..853a346f802136c9539eb1a075dea65fdf2a5ad7 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp @@ -95,7 +95,7 @@ static int32_t AgreeKey(const struct HksTestAgreeParamSet *agreeParamSetParams, * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp index 5f29d8b0d8e80f181175f9735be0e1b813156c91..f02684893b40f649674b839efc537eb8af0b1c52 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp @@ -95,7 +95,7 @@ static int32_t TestValue() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level1) +HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level0) { int32_t ret; if (g_testBnExpModParams[0].isTestValue) { diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp index e8712309331625578986c7281d7b7b3286bef34f..35bcc3000453b17dd98aec97060711c9eb168f31 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp @@ -55,62 +55,62 @@ void HksCipherTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 4, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 4, 1) == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp index 4358783239d2d44f1b34b3ab75f9a027ff0ae51e..0a41d0ecf4d6bc221bfc2451cef21ceec8669f2f 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp @@ -55,7 +55,7 @@ void HksCurve25519Test::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level0) { ASSERT_TRUE(TestCurve25519All() == 0); } @@ -65,7 +65,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level0) { ASSERT_TRUE(TestEd25519SignTeeVerifyLocal() == 0); } @@ -75,7 +75,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level0) { ASSERT_TRUE(TestCurve25519SignWrong() == 0); } @@ -85,7 +85,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level0) { ASSERT_TRUE(TestCurve25519verifyWrong() == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp index 590db98af775837f036697a644caa4e628160ef2..6f13446cf607bd430962f87587474edc614b6b2e 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp @@ -63,7 +63,7 @@ static const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level1) +HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp index e22c75c82f8b2d14b0544b688d5b85264ea776c2..3c3a664c3e812d9098f7362f11720bea35c02b3b 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp @@ -201,7 +201,7 @@ static int32_t BaseTestDerive(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level0) { int32_t ret = BaseTestDerive(0); ASSERT_TRUE(ret == 0); @@ -212,7 +212,7 @@ HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level0) { int32_t ret = BaseTestDerive(1); ASSERT_TRUE(ret == 0); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp index 0947b2096980d0e1b3996ac809c6ef2d51223939..a77884dcdafdb68e8254d86209cfa2b6b312aee8 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp @@ -63,7 +63,7 @@ static const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level1) +HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp index 7d90af02ffdc52d9d9979c01644fa97ade3f7f7d..603080b0a415f556cfe2d1320667d512df17bb78 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp @@ -74,7 +74,7 @@ static const struct HksTestGenKeyParams g_testGenKeyParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level1) +HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level0) { uint32_t times = 1; uint32_t index = 0; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp index 1fc293fd56518cf91accb928980ba4756c017a84..80581908c9bfd59b58ca8864e4b076ea5c271cfd 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp @@ -62,7 +62,7 @@ static const struct HksTestGenRandomParams g_testGenRandomParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level1) +HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level0) { int32_t ret; struct HksBlob *random = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp index 9b4136a4315def36da00875987ade9bcd8194308..a181adf94d3ccaf59d47d9e230591ee89b08c1ae 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp @@ -70,7 +70,7 @@ static const struct HksTestHashParams g_testHashParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level1) +HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level0) { struct HksParamSet *paramSet = NULL; struct HksBlob *srcData = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..6009b2e8c36dd931a6d0a1d5ee37eb727c5a97de --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp @@ -0,0 +1,409 @@ +/* + * Copyright (C) 2021 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 "hks_base_check.h" +#include "hks_check_paramset.h" +#include "hks_client_service_adapter.h" +#include "hks_cmd_id.h" +#include "hks_common_check.h" +#include "hks_crypto_adapter.h" +#include "hks_local_engine.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksInnerTest : public testing::Test {}; + +/** + * @tc.name: HksInnerTest.HksInnerTest001 + * @tc.desc: CheckPurposeValid HMAC & DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest001, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + ret = HksCheckGenKeyPurpose(HKS_ALG_HMAC, HKS_KEY_PURPOSE_MAC); + ASSERT_EQ(ret, HKS_SUCCESS); + ret = HksCheckGenKeyPurpose(HKS_ALG_DSA, HKS_KEY_PURPOSE_SIGN); + ASSERT_EQ(ret, HKS_SUCCESS); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest002 + * @tc.desc: InitInputParamsByAlg HMAC & DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest002, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + ret = HksGetInputParmasByAlg(HKS_ALG_HMAC, HKS_CHECK_TYPE_GEN_KEY, NULL, NULL); + ret = HksGetInputParmasByAlg(HKS_ALG_DSA, HKS_CHECK_TYPE_GEN_KEY, NULL, NULL); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest003 + * @tc.desc: GetExpectParams HMAC & DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest003, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + ParamsValues values = {0, 0, 0, 0, 0}; + ret = HksCheckFixedParams(HKS_ALG_HMAC, HKS_CHECK_TYPE_GEN_KEY, &values); + ret = HksCheckFixedParams(HKS_ALG_DSA, HKS_CHECK_TYPE_GEN_KEY, &values); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest004 + * @tc.desc: CheckAesPadding CTR & ECB mode + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest004, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + ParamsValues values = { + {0}, + {.needCheck = true, .value = HKS_PADDING_NONE}, + {.needCheck = true, .value = HKS_KEY_PURPOSE_ENCRYPT}, + {0}, + {.needCheck = true, .value = HKS_MODE_CTR}, + }; + ret = HksCheckGenKeyMutableParams(HKS_ALG_AES, &values); + values.mode = {.needCheck = true, .value = HKS_MODE_ECB}; + ret = HksCheckGenKeyMutableParams(HKS_ALG_AES, &values); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest005 + * @tc.desc: CheckImportMutableParams CTR & ECB mode + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest005, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + ret = CheckImportMutableParams(HKS_ALG_AES, NULL); + + ParamsValues values = { + {0}, + {.needCheck = true, .value = HKS_PADDING_NONE}, + {.needCheck = true, .value = HKS_KEY_PURPOSE_ENCRYPT}, + {0}, + {0}, + }; + ret = CheckImportMutableParams(HKS_ALG_ECC, &values); + ASSERT_EQ(ret, HKS_ERROR_INVALID_PURPOSE); + + ret = CheckImportMutableParams(HKS_ALG_RSA, &values); + + values.purpose = {.needCheck = true, .value = HKS_KEY_PURPOSE_VERIFY}; + ret = CheckImportMutableParams(HKS_ALG_RSA, &values); + + values.purpose = {.needCheck = true, .value = HKS_KEY_PURPOSE_SIGN}; + ret = CheckImportMutableParams(HKS_ALG_RSA, &values); + ASSERT_EQ(ret, HKS_ERROR_INVALID_PURPOSE); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest006 + * @tc.desc: CheckImportKeySize DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest006, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + ParamsValues values = { + {0}, + {.needCheck = true, .value = HKS_PADDING_NONE}, + {.needCheck = true, .value = HKS_KEY_PURPOSE_ENCRYPT}, + {0}, + {0}, + }; + HksBlob keyAlias = {0}; + HksBlob key = {0}; + HksParamSet *paramSet = nullptr; + HksBlob keyOut = {0}; + + ret = HksInitParamSet(¶mSet); + ASSERT_EQ(ret, HKS_SUCCESS); + + HksParam algrithom; + algrithom.tag = HKS_TAG_ALGORITHM; + algrithom.uint32Param = HKS_ALG_DSA; + HksAddParams(paramSet, &algrithom, 1); + + HksParam keySize; + keySize.tag = HKS_TAG_KEY_SIZE; + keySize.uint32Param = 256; + HksAddParams(paramSet, &keySize, 1); + + HksParam purpose; + purpose.tag = HKS_TAG_PURPOSE; + purpose.uint32Param = HKS_KEY_PURPOSE_SIGN; + HksAddParams(paramSet, &purpose, 1); + + HksParam digest; + digest.tag = HKS_TAG_DIGEST; + digest.uint32Param = HKS_DIGEST_SHA256; + HksAddParams(paramSet, &digest, 1); + + ret = HksCoreCheckImportKeyParams(&keyAlias, &key, paramSet, &keyOut); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest007 + * @tc.desc: CheckImportKeySize DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest007, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + ParamsValues values = { + {0}, + {.needCheck = true, .value = HKS_PADDING_NONE}, + {.needCheck = true, .value = HKS_KEY_PURPOSE_ENCRYPT}, + {0}, + {0}, + }; + HksBlob keyAlias = {0}; + HksBlob key = {0}; + HksParamSet *paramSet = nullptr; + HksBlob keyOut = {0}; + + ret = HksInitParamSet(¶mSet); + ASSERT_EQ(ret, HKS_SUCCESS); + + HksParam algrithom; + algrithom.tag = HKS_TAG_ALGORITHM; + algrithom.uint32Param = HKS_ALG_DSA; + HksAddParams(paramSet, &algrithom, 1); + + HksParam keySize; + keySize.tag = HKS_TAG_KEY_SIZE; + keySize.uint32Param = 256; + HksAddParams(paramSet, &keySize, 1); + + HksParam purpose; + purpose.tag = HKS_TAG_PURPOSE; + purpose.uint32Param = HKS_KEY_PURPOSE_SIGN; + HksAddParams(paramSet, &purpose, 1); + + HksParam digest; + digest.tag = HKS_TAG_DIGEST; + digest.uint32Param = HKS_DIGEST_SHA256; + HksAddParams(paramSet, &digest, 1); + + HksBuildParamSet(¶mSet); + + ret = HksCoreCheckImportKeyParams(&keyAlias, &key, paramSet, &keyOut); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest008 + * @tc.desc: HksLocalCheckCipherParams AES RSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest008, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + HksParamSet *paramSet = nullptr; + + HksParam algrithom; + algrithom.tag = HKS_TAG_ALGORITHM; + algrithom.uint32Param = HKS_ALG_AES; + + ret = HksInitParamSet(¶mSet); + ASSERT_EQ(ret, HKS_SUCCESS); + HksAddParams(paramSet, &algrithom, 1); + HksBuildParamSet(¶mSet); + + ret = HksLocalCheckCipherParams(HKS_CMD_ID_ENCRYPT, HKS_AES_KEY_SIZE_512, paramSet, nullptr, nullptr); + HksFreeParamSet(¶mSet); + + ret = HksInitParamSet(¶mSet); + ASSERT_EQ(ret, HKS_SUCCESS); + algrithom.uint32Param = HKS_ALG_RSA; + HksAddParams(paramSet, &algrithom, 1); + HksBuildParamSet(¶mSet); + + ret = HksLocalCheckCipherParams(HKS_CMD_ID_ENCRYPT, HKS_RSA_KEY_SIZE_1024, paramSet, nullptr, nullptr); + ret = HksLocalCheckCipherParams(HKS_CMD_ID_ENCRYPT, 0, paramSet, nullptr, nullptr); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest009 + * @tc.desc: HksGetDigestLen sha1 sha224 digest + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest009, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + uint32_t len; + ret = HksGetDigestLen(HKS_DIGEST_SHA1, &len); + ret = HksGetDigestLen(HKS_DIGEST_SHA224, &len); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest010 + * @tc.desc: HksFormatKeyFromMaterial AES RSA HMAC DSA ECC algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest010, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + uint32_t len; + HksBlob keyMaterial = {.size = 0, .data = nullptr}; + ret = HksFormatKeyFromMaterial(HKS_ALG_AES, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_RSA, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_HMAC, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_DSA, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_ECC, &keyMaterial, nullptr); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest011 + * @tc.desc: HksFormatKeyFromMaterial AES RSA HMAC DSA ECC algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest011, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + uint32_t len; + HksBlob keyMaterial = {.size = 0, .data = nullptr}; + ret = HksFormatKeyFromMaterial(HKS_ALG_AES, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_RSA, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_HMAC, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_DSA, &keyMaterial, nullptr); + ret = HksFormatKeyFromMaterial(HKS_ALG_ECC, &keyMaterial, nullptr); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest012 + * @tc.desc: CheckLocalGenerateKeyParams function + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest012, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + HksParamSet *inParamSet = nullptr; + HksParamSet *outParamSet = nullptr; + + ret = HksInitParamSet(&inParamSet); + ASSERT_EQ(ret, HKS_SUCCESS); + ret = HksInitParamSet(&outParamSet); + ASSERT_EQ(ret, HKS_SUCCESS); + + HksParam keySize; + keySize.tag = HKS_TAG_KEY_SIZE; + keySize.uint32Param = 256; + HksAddParams(inParamSet, &keySize, 1); + + HksParam purpose; + purpose.tag = HKS_TAG_PURPOSE; + purpose.uint32Param = HKS_KEY_PURPOSE_SIGN; + HksAddParams(inParamSet, &purpose, 1); + + HksParam digest; + digest.tag = HKS_TAG_DIGEST; + digest.uint32Param = HKS_DIGEST_SHA256; + HksAddParams(inParamSet, &digest, 1); + + ret = HksLocalGenerateKey(inParamSet, nullptr); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + ret = HksLocalGenerateKey(inParamSet, outParamSet); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + + HksParam algrithom; + algrithom.tag = HKS_TAG_ALGORITHM; + algrithom.uint32Param = HKS_ALG_DSA; + HksAddParams(inParamSet, &algrithom, 1); + + ret = HksLocalGenerateKey(inParamSet, outParamSet); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest013 + * @tc.desc: CheckLocalCipherParams AES RSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest013, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + HksParamSet *inParamSet = nullptr; + KeyMaterialRsa keyMaterial = {.keyAlg = HKS_ALG_RSA, .keySize = HKS_RSA_KEY_SIZE_512}; + HksBlob blobArg = {.size = sizeof(KeyMaterialRsa), .data = (uint8_t *)&keyMaterial}; + HksParam algrithom; + algrithom.tag = HKS_TAG_ALGORITHM; + algrithom.uint32Param = HKS_ALG_DSA; + + ret = HksInitParamSet(&inParamSet); + ASSERT_EQ(ret, HKS_SUCCESS); + HksAddParams(inParamSet, &algrithom, 1); + ret = HksLocalEncrypt(&blobArg, inParamSet, &blobArg, &blobArg); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ALGORITHM); + HksFreeParamSet(&inParamSet); + + ret = HksInitParamSet(&inParamSet); + ASSERT_EQ(ret, HKS_SUCCESS); + algrithom.uint32Param = HKS_ALG_AES; + HksAddParams(inParamSet, &algrithom, 1); + ret = HksLocalEncrypt(&blobArg, inParamSet, &blobArg, &blobArg); + HksFreeParamSet(&inParamSet); + + ret = HksInitParamSet(&inParamSet); + ASSERT_EQ(ret, HKS_SUCCESS); + algrithom.uint32Param = HKS_ALG_RSA; + HksAddParams(inParamSet, &algrithom, 1); + ret = HksLocalEncrypt(&blobArg, inParamSet, &blobArg, &blobArg); + HksFreeParamSet(&inParamSet); +} + +/** + * @tc.name: HksInnerTest.HksInnerTest014 + * @tc.desc: TranslateToX509PublicKey and TranslateFromX509PublicKey DSA algrithom + * @tc.type: FUNC + */ +HWTEST_F(HksInnerTest, HksInnerTest014, Function | SmallTest | Level0) +{ + int32_t ret = HKS_SUCCESS; + + HksBlob publicKey = {.size = sizeof(KeyMaterialDsa) + 5, .data = (uint8_t *)HksMalloc(sizeof(KeyMaterialDsa) + 5)}; + HksBlob x509Key = {.size = 0, .data = nullptr}; + KeyMaterialDsa *keyMaterial = (KeyMaterialDsa *)publicKey.data; + memset_s(publicKey.data, publicKey.size, 0x01, publicKey.size); + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = 256; + + publicKey.size = 20; + ret = TranslateToX509PublicKey(&publicKey, &x509Key); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + + publicKey.size = sizeof(KeyMaterialDsa) + 5; + keyMaterial->xSize = 1; + keyMaterial->ySize = 1; + keyMaterial->pSize = 1; + keyMaterial->qSize = 1; + keyMaterial->gSize = 1; + ret = TranslateToX509PublicKey(&publicKey, &x509Key); + + ret = TranslateFromX509PublicKey(&x509Key, &publicKey); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp index 6e57e1c578d08295f41858559d519391cb664359..501d43223161b2cfc90dc819ad82e7948de2ea85 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp @@ -181,7 +181,7 @@ static int32_t BaseTestMac(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level0) { int32_t ret = BaseTestMac(0); ASSERT_TRUE(ret == 0); @@ -192,7 +192,7 @@ HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level0) { int32_t ret = BaseTestMac(1); ASSERT_TRUE(ret == 0); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp index 7e68aadbb0b2a448f04c7070d077e01d6c6eae5a..b5f73050bf048b2ac8d07290992c77946e998bed 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp @@ -302,7 +302,7 @@ int32_t BaseTestCipher(struct HksBlob *keyAlias, uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level1) +HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level0) { uint32_t index = 0; struct HksBlob keyAlias = { strlen(g_testName), (uint8_t *)g_testName }; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp index f0c9ae90b9883ae9308a87686cac5ad867d63442..ba3ecfb278a5e475e156345ebc163796a4b6ebe2 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp @@ -55,7 +55,7 @@ void HksOthersTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level0) { int32_t ret = HksGetKeyParamSet(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -66,7 +66,7 @@ HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level0) { int32_t ret = HksGetKeyInfoList(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -77,7 +77,7 @@ HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level0) { int32_t ret = HksAttestKey(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -88,7 +88,7 @@ HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level0) { int32_t ret = HksGetCertificateChain(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -99,7 +99,7 @@ HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level0) { int32_t ret = HksWrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -110,7 +110,7 @@ HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level0) { int32_t ret = HksUnwrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -121,7 +121,7 @@ HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level0) { int32_t ret = HksGetSdkVersion(NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -132,7 +132,7 @@ HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level0) { int32_t ret = HksInitialize(); ASSERT_TRUE(ret == HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp index c537aa21f23ddd04f633373f1e9ee9400c967d9d..b32b7ca8801f733f528a377a440d738efc9c3660 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp @@ -84,7 +84,7 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level0) { struct HksBlob ed25519Alias = { strlen(g_testEd25519), (uint8_t *)g_testEd25519 }; int32_t ret = TestGenerateEd25519Key(ed25519Alias); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp index bc4a081bf2cd6974454d2a2cb65945812edf2818..e476ad8d8cefba480b8b1780914e4d41ae313ae4 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp @@ -143,7 +143,7 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level0) { struct HksBlob keyAliasOne = { strlen(g_testOne), (uint8_t *)g_testOne }; int32_t ret = SafeTestGenerateKey(&keyAliasOne); diff --git a/interfaces/kits/js/@ohos.security.huks.d.ts b/interfaces/kits/js/@ohos.security.huks.d.ts new file mode 100755 index 0000000000000000000000000000000000000000..9d2af17b75344a283f26dea2ca5306692b466bb5 --- /dev/null +++ b/interfaces/kits/js/@ohos.security.huks.d.ts @@ -0,0 +1,411 @@ + +/* +* Copyright (c) 2021 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. +*/ + +import {AsyncCallback} from './basic'; + +declare namespace huks { + function generateKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function generateKey(keyAlias: string, options: HksOptions) : Promise; + + function deleteKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function deleteKey(keyAlias: string, options: HksOptions) : Promise; + + function encrypt(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function encrypt(keyAlias: string, options: HksOptions) : Promise; + + function decrypt(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function decrypt(keyAlias: string, options: HksOptions) : Promise; + + function getSdkVersion(options: HksOptions) : string; + + function importKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function importKey(keyAlias: string, options: HksOptions) : Promise; + + function exportKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function exportKey(keyAlias: string, options: HksOptions) : Promise; + + function getKeyProperties(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function getKeyProperties(keyAlias: string, options: HksOptions) : Promise; + + function isKeyExist(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function isKeyExist(keyAlias: string, options: HksOptions) : Promise; + + function sign(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function sign(keyAlias: string, options: HksOptions) : Promise; + + function verify( + keyAlias: string, options: HksOptions, signature: Uint8Array, callback: AsyncCallback) : void; + function verify(keyAlias: string, options: HksOptions, signature: Uint8Array) : Promise; + + function agreeKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function agreeKey(keyAlias: string, options: HksOptions) : Promise; + + function deriveKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function deriveKey(keyAlias: string, options: HksOptions) : Promise; + + function mac(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function mac(keyAlias: string, options: HksOptions) : Promise; + + function attestKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function attestKey(keyAlias: string, options: HksOptions) : Promise; + + function getCertificateChain(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function getCertificateChain(keyAlias: string, options: HksOptions) : Promise; + + function wrapKey(keyAlias: string, targetKeyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function wrapKey(keyAlias: string, targetKeyAlias: string, options: HksOptions) : Promise; + + function unwrapKey(keyAlias: string, targetKeyAlias: string, options: HksOptions, callback: AsyncCallback) : void; + function unwrapKey(keyAlias: string, targetKeyAlias: string, options: HksOptions) : Promise; + + export interface HksParam { + tag: HksTag; + value: boolean | number | bigint | Uint8Array; + } + + export interface HksOptions { + properties?: Array; + inData?: Uint8Array; + } + + export interface HksResult { + errorCode: number; + outData?: Uint8Array; + properties?: Array; + certChains?: Array; + } + + export enum HksErrorCode { + HKS_SUCCESS = 0, + HKS_FAILURE = -1, + HKS_ERROR_BAD_STATE = -2, + HKS_ERROR_INVALID_ARGUMENT = -3, + HKS_ERROR_NOT_SUPPORTED = -4, + HKS_ERROR_NO_PERMISSION = -5, + HKS_ERROR_INSUFFICIENT_DATA = -6, + HKS_ERROR_BUFFER_TOO_SMALL = -7, + HKS_ERROR_INSUFFICIENT_MEMORY = -8, + HKS_ERROR_COMMUNICATION_FAILURE = -9, + HKS_ERROR_STORAGE_FAILURE = -10, + HKS_ERROR_HARDWARE_FAILURE = -11, + HKS_ERROR_ALREADY_EXISTS = -12, + HKS_ERROR_NOT_EXIST = -13, + HKS_ERROR_NULL_POINTER = -14, + HKS_ERROR_FILE_SIZE_FAIL = -15, + HKS_ERROR_READ_FILE_FAIL = -16, + HKS_ERROR_INVALID_PUBLIC_KEY = -17, + HKS_ERROR_INVALID_PRIVATE_KEY = -18, + HKS_ERROR_INVALID_KEY_INFO = -19, + HKS_ERROR_HASH_NOT_EQUAL = -20, + HKS_ERROR_MALLOC_FAIL = -21, + HKS_ERROR_WRITE_FILE_FAIL = -22, + HKS_ERROR_REMOVE_FILE_FAIL = -23, + HKS_ERROR_OPEN_FILE_FAIL = -24, + HKS_ERROR_CLOSE_FILE_FAIL = -25, + HKS_ERROR_MAKE_DIR_FAIL = -26, + HKS_ERROR_INVALID_KEY_FILE = -27, + HKS_ERROR_IPC_MSG_FAIL = -28, + HKS_ERROR_REQUEST_OVERFLOWS = -29, + HKS_ERROR_PARAM_NOT_EXIST = -30, + HKS_ERROR_CRYPTO_ENGINE_ERROR = -31, + HKS_ERROR_COMMUNICATION_TIMEOUT = -32, + HKS_ERROR_IPC_INIT_FAIL = -33, + HKS_ERROR_IPC_DLOPEN_FAIL = -34, + HKS_ERROR_EFUSE_READ_FAIL = -35, + HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST = -36, + HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL = -37, + + HKS_ERROR_CHECK_GET_ALG_FAIL = -100, + HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL = -101, + HKS_ERROR_CHECK_GET_PADDING_FAIL = -102, + HKS_ERROR_CHECK_GET_PURPOSE_FAIL = -103, + HKS_ERROR_CHECK_GET_DIGEST_FAIL = -104, + HKS_ERROR_CHECK_GET_MODE_FAIL = -105, + HKS_ERROR_CHECK_GET_NONCE_FAIL = -106, + HKS_ERROR_CHECK_GET_AAD_FAIL = -107, + HKS_ERROR_CHECK_GET_IV_FAIL = -108, + HKS_ERROR_CHECK_GET_AE_TAG_FAIL = -109, + HKS_ERROR_CHECK_GET_SALT_FAIL = -110, + HKS_ERROR_CHECK_GET_ITERATION_FAIL = -111, + HKS_ERROR_INVALID_ALGORITHM = -112, + HKS_ERROR_INVALID_KEY_SIZE = -113, + HKS_ERROR_INVALID_PADDING = -114, + HKS_ERROR_INVALID_PURPOSE = -115, + HKS_ERROR_INVALID_MODE = -116, + HKS_ERROR_INVALID_DIGEST = -117, + HKS_ERROR_INVALID_SIGNATURE_SIZE = -118, + HKS_ERROR_INVALID_IV = -119, + HKS_ERROR_INVALID_AAD = -120, + HKS_ERROR_INVALID_NONCE = -121, + HKS_ERROR_INVALID_AE_TAG = -122, + HKS_ERROR_INVALID_SALT = -123, + HKS_ERROR_INVALID_ITERATION = -124, + HKS_ERROR_INVALID_OPERATION = -125, + + HKS_ERROR_INTERNAL_ERROR = -999, + HKS_ERROR_UNKNOWN_ERROR = -1000, + } + + export enum HksKeyType { + HKS_KEY_TYPE_RSA_PUBLIC_KEY = 0x01001000, + HKS_KEY_TYPE_RSA_KEYPAIR = 0x01002000, + + HKS_KEY_TYPE_ECC_P256_PUBLIC_KEY = 0x02021000, + HKS_KEY_TYPE_ECC_P256_KEYPAIR = 0x02022000, + HKS_KEY_TYPE_ECC_P384_PUBLIC_KEY = 0x02031000, + HKS_KEY_TYPE_ECC_P384_KEYPAIR = 0x02032000, + HKS_KEY_TYPE_ECC_P521_PUBLIC_KEY = 0x02051000, + HKS_KEY_TYPE_ECC_P521_KEYPAIR = 0x02052000, + + HKS_KEY_TYPE_ED25519_PUBLIC_KEY = 0x02101000, + HKS_KEY_TYPE_ED25519_KEYPAIR = 0x02102000, + HKS_KEY_TYPE_X25519_PUBLIC_KEY = 0x02111000, + HKS_KEY_TYPE_X25519_KEYPAIR = 0x02112000, + + HKS_KEY_TYPE_AES = 0x03000000, + HKS_KEY_TYPE_CHACHA20 = 0x04010000, + HKS_KEY_TYPE_CHACHA20_POLY1305 = 0x04020000, + + HKS_KEY_TYPE_HMAC = 0x05000000, + HKS_KEY_TYPE_HKDF = 0x06000000, + HKS_KEY_TYPE_PBKDF2 = 0x07000000, + } + + export enum HksKeyPurpose { + HKS_KEY_PURPOSE_ENCRYPT = 1, /* Usable with RSA, EC and AES keys. */ + HKS_KEY_PURPOSE_DECRYPT = 2, /* Usable with RSA, EC and AES keys. */ + HKS_KEY_PURPOSE_SIGN = 4, /* Usable with RSA, EC keys. */ + HKS_KEY_PURPOSE_VERIFY = 8, /* Usable with RSA, EC keys. */ + HKS_KEY_PURPOSE_DERIVE = 16, /* Usable with EC keys. */ + HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ + HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ + HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ + } + + export enum HksKeyDigest { + HKS_DIGEST_NONE = 0, + HKS_DIGEST_MD5 = 1, + HKS_DIGEST_SHA1 = 10, + HKS_DIGEST_SHA224 = 11, + HKS_DIGEST_SHA256 = 12, + HKS_DIGEST_SHA384 = 13, + HKS_DIGEST_SHA512 = 14, + } + + export enum HksKeyPadding { + HKS_PADDING_NONE = 0, + HKS_PADDING_OAEP = 1, + HKS_PADDING_PSS = 2, + HKS_PADDING_PKCS1_V1_5 = 3, + HKS_PADDING_PKCS5 = 4, + HKS_PADDING_PKCS7 = 5, + } + + export enum HksCipherMode { + HKS_MODE_ECB = 1, + HKS_MODE_CBC = 2, + HKS_MODE_CTR = 3, + HKS_MODE_OFB = 4, + HKS_MODE_CCM = 31, + HKS_MODE_GCM = 32, + } + + export enum HksKeySize { + HKS_RSA_KEY_SIZE_512 = 512, + HKS_RSA_KEY_SIZE_768 = 768, + HKS_RSA_KEY_SIZE_1024 = 1024, + HKS_RSA_KEY_SIZE_2048 = 2048, + HKS_RSA_KEY_SIZE_3072 = 3072, + HKS_RSA_KEY_SIZE_4096 = 4096, + + HKS_ECC_KEY_SIZE_224 = 224, + HKS_ECC_KEY_SIZE_256 = 256, + HKS_ECC_KEY_SIZE_384 = 384, + HKS_ECC_KEY_SIZE_521 = 521, + + HKS_AES_KEY_SIZE_128 = 128, + HKS_AES_KEY_SIZE_192 = 192, + HKS_AES_KEY_SIZE_256 = 256, + HKS_AES_KEY_SIZE_512 = 512, + + HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, + } + + export enum HksKeyAlg { + HKS_ALG_RSA = 1, + HKS_ALG_ECC = 2, + HKS_ALG_DSA = 3, + + HKS_ALG_AES = 20, + HKS_ALG_HMAC = 50, + HKS_ALG_HKDF = 51, + HKS_ALG_PBKDF2 = 52, + + HKS_ALG_ECDH = 100, + HKS_ALG_X25519 = 101, + HKS_ALG_ED25519 = 102, + HKS_ALG_DH = 103, + } + + export enum HksKeyGenerateType { + HKS_KEY_GENERATE_TYPE_DEFAULT = 0, + HKS_KEY_GENERATE_TYPE_DERIVE = 1, + HKS_KEY_GENERATE_TYPE_AGREE = 2, + } + + export enum HksKeyFlag { + HKS_KEY_FLAG_IMPORT_KEY = 1, + HKS_KEY_FLAG_GENERATE_KEY = 2, + } + + export enum HksKeyStorageType { + HKS_STORAGE_TEMP = 0, + HKS_STORAGE_PERSISTENT = 1, + } + + export enum HksSendType { + HKS_SEND_TYPE_ASYNC = 0, + HKS_SEND_TYPE_SYNC = 1, + } + + declare enum HksTagType { + HKS_TAG_TYPE_INVALID = 0 << 28, + HKS_TAG_TYPE_INT = 1 << 28, + HKS_TAG_TYPE_UINT = 2 << 28, + HKS_TAG_TYPE_ULONG = 3 << 28, + HKS_TAG_TYPE_BOOL = 4 << 28, + HKS_TAG_TYPE_BYTES = 5 << 28, + } + + export enum HksTag { + /* Invalid TAG */ + HKS_TAG_INVALID = HksTagType.HKS_TAG_TYPE_INVALID | 0, + + /* Base algrithom TAG: 1 - 200 */ + HKS_TAG_ALGORITHM = HksTagType.HKS_TAG_TYPE_UINT | 1, + HKS_TAG_PURPOSE = HksTagType.HKS_TAG_TYPE_UINT | 2, + HKS_TAG_KEY_SIZE = HksTagType.HKS_TAG_TYPE_UINT | 3, + HKS_TAG_DIGEST = HksTagType.HKS_TAG_TYPE_UINT | 4, + HKS_TAG_PADDING = HksTagType.HKS_TAG_TYPE_UINT | 5, + HKS_TAG_BLOCK_MODE = HksTagType.HKS_TAG_TYPE_UINT | 6, + HKS_TAG_KEY_TYPE = HksTagType.HKS_TAG_TYPE_UINT | 7, + HKS_TAG_ASSOCIATED_DATA = HksTagType.HKS_TAG_TYPE_BYTES | 8, + HKS_TAG_NONCE = HksTagType.HKS_TAG_TYPE_BYTES | 9, + HKS_TAG_IV = HksTagType.HKS_TAG_TYPE_BYTES | 10, + + /* Key derivation TAG */ + HKS_TAG_INFO = HksTagType.HKS_TAG_TYPE_BYTES | 11, + HKS_TAG_SALT = HksTagType.HKS_TAG_TYPE_BYTES | 12, + HKS_TAG_PWD = HksTagType.HKS_TAG_TYPE_BYTES | 13, + HKS_TAG_ITERATION = HksTagType.HKS_TAG_TYPE_UINT | 14, + + HKS_TAG_KEY_GENERATE_TYPE = HksTagType.HKS_TAG_TYPE_UINT | 15, /* choose from enum HksKeyGenerateType */ + HKS_TAG_DERIVE_MAIN_KEY = HksTagType.HKS_TAG_TYPE_BYTES | 16, + HKS_TAG_DERIVE_FACTOR = HksTagType.HKS_TAG_TYPE_BYTES | 17, + HKS_TAG_DERIVE_ALG = HksTagType.HKS_TAG_TYPE_UINT | 18, + HKS_TAG_AGREE_ALG = HksTagType.HKS_TAG_TYPE_UINT | 19, + HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS = HksTagType.HKS_TAG_TYPE_BOOL | 20, + HKS_TAG_AGREE_PRIVATE_KEY_ALIAS = HksTagType.HKS_TAG_TYPE_BYTES | 21, + HKS_TAG_AGREE_PUBLIC_KEY = HksTagType.HKS_TAG_TYPE_BYTES | 22, + + /* + * Key authentication related TAG: 201 - 300 + * + * Start of validity + */ + HKS_TAG_ACTIVE_DATETIME = HksTagType.HKS_TAG_TYPE_ULONG | 201, + + /* Date when new "messages" should not be created. */ + HKS_TAG_ORIGINATION_EXPIRE_DATETIME = HksTagType.HKS_TAG_TYPE_ULONG | 202, + + /* Date when existing "messages" should not be used. */ + HKS_TAG_USAGE_EXPIRE_DATETIME = HksTagType.HKS_TAG_TYPE_ULONG | 203, + + /* Key creation time */ + HKS_TAG_CREATION_DATETIME = HksTagType.HKS_TAG_TYPE_ULONG | 204, + + /* Other authentication related TAG: 301 - 500 */ + HKS_TAG_ALL_USERS = HksTagType.HKS_TAG_TYPE_BOOL | 301, + HKS_TAG_USER_ID = HksTagType.HKS_TAG_TYPE_UINT | 302, + HKS_TAG_NO_AUTH_REQUIRED = HksTagType.HKS_TAG_TYPE_BOOL | 303, + HKS_TAG_USER_AUTH_TYPE = HksTagType.HKS_TAG_TYPE_UINT | 304, + HKS_TAG_AUTH_TIMEOUT = HksTagType.HKS_TAG_TYPE_UINT | 305, + HKS_TAG_AUTH_TOKEN = HksTagType.HKS_TAG_TYPE_BYTES | 306, + + /* Attestation related TAG: 501 - 600 */ + HKS_TAG_ATTESTATION_CHALLENGE = HksTagType.HKS_TAG_TYPE_BYTES | 501, + HKS_TAG_ATTESTATION_APPLICATION_ID = HksTagType.HKS_TAG_TYPE_BYTES | 502, + HKS_TAG_ATTESTATION_ID_BRAND = HksTagType.HKS_TAG_TYPE_BYTES | 503, + HKS_TAG_ATTESTATION_ID_DEVICE = HksTagType.HKS_TAG_TYPE_BYTES | 504, + HKS_TAG_ATTESTATION_ID_PRODUCT = HksTagType.HKS_TAG_TYPE_BYTES | 505, + HKS_TAG_ATTESTATION_ID_SERIAL = HksTagType.HKS_TAG_TYPE_BYTES | 506, + HKS_TAG_ATTESTATION_ID_IMEI = HksTagType.HKS_TAG_TYPE_BYTES | 507, + HKS_TAG_ATTESTATION_ID_MEID = HksTagType.HKS_TAG_TYPE_BYTES | 508, + HKS_TAG_ATTESTATION_ID_MANUFACTURER = HksTagType.HKS_TAG_TYPE_BYTES | 509, + HKS_TAG_ATTESTATION_ID_MODEL = HksTagType.HKS_TAG_TYPE_BYTES | 510, + HKS_TAG_ATTESTATION_ID_ALIAS = HksTagType.HKS_TAG_TYPE_BYTES | 511, + + /* + * Other reserved TAG: 601 - 1000 + * + * Extention TAG: 1001 - 9999 + */ + HKS_TAG_IS_KEY_ALIAS = HksTagType.HKS_TAG_TYPE_BOOL | 1001, + HKS_TAG_KEY_STORAGE_FLAG = HksTagType.HKS_TAG_TYPE_UINT | 1002, /* choose from enum HksKeyStorageType */ + HKS_TAG_IS_ALLOWED_WRAP = HksTagType.HKS_TAG_TYPE_BOOL | 1003, + HKS_TAG_KEY_WRAP_TYPE = HksTagType.HKS_TAG_TYPE_UINT | 1004, + HKS_TAG_KEY_AUTH_ID = HksTagType.HKS_TAG_TYPE_BYTES | 1005, + HKS_TAG_KEY_ROLE = HksTagType.HKS_TAG_TYPE_UINT | 1006, + HKS_TAG_KEY_FLAG = HksTagType.HKS_TAG_TYPE_UINT | 1007, /* choose from enum HksKeyFlag */ + HKS_TAG_IS_ASYNCHRONIZED = HksTagType.HKS_TAG_TYPE_UINT | 1008, + HKS_TAG_SECURE_KEY_ALIAS = HksTagType.HKS_TAG_TYPE_BOOL | 1009, + HKS_TAG_SECURE_KEY_UUID = HksTagType.HKS_TAG_TYPE_BYTES | 1010, + HKS_TAG_KEY_DOMAIN = HksTagType.HKS_TAG_TYPE_UINT | 1011, + + /* Inner-use TAG: 10001 - 10999 */ + HKS_TAG_PROCESS_NAME = HksTagType.HKS_TAG_TYPE_BYTES | 10001, + HKS_TAG_PACKAGE_NAME = HksTagType.HKS_TAG_TYPE_BYTES | 10002, + HKS_TAG_ACCESS_TIME = HksTagType.HKS_TAG_TYPE_UINT | 10003, + HKS_TAG_USES_TIME = HksTagType.HKS_TAG_TYPE_UINT | 10004, + HKS_TAG_CRYPTO_CTX = HksTagType.HKS_TAG_TYPE_ULONG | 10005, + HKS_TAG_KEY = HksTagType.HKS_TAG_TYPE_BYTES | 10006, + HKS_TAG_KEY_VERSION = HksTagType.HKS_TAG_TYPE_UINT | 10007, + HKS_TAG_PAYLOAD_LEN = HksTagType.HKS_TAG_TYPE_UINT | 10008, + HKS_TAG_AE_TAG = HksTagType.HKS_TAG_TYPE_BYTES | 10009, + HKS_TAG_IS_KEY_HANDLE = HksTagType.HKS_TAG_TYPE_ULONG | 10010, + + /* Os version related TAG */ + HKS_TAG_OS_VERSION = HksTagType.HKS_TAG_TYPE_UINT | 10101, + HKS_TAG_OS_PATCHLEVEL = HksTagType.HKS_TAG_TYPE_UINT | 10102, + + /* + * Reversed TAGs for SOTER: 11000 - 12000 + * + * Other TAGs: 20001 - N + * TAGs used for paramSetOut + */ + HKS_TAG_SYMMETRIC_KEY_DATA = HksTagType.HKS_TAG_TYPE_BYTES | 20001, + HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA = HksTagType.HKS_TAG_TYPE_BYTES | 20002, + HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA = HksTagType.HKS_TAG_TYPE_BYTES | 20003, + } +} + +export default huks; diff --git a/interfaces/kits/napi/BUILD.gn b/interfaces/kits/napi/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..6fddff860313a205bc548e76b862471f7cfae388 --- /dev/null +++ b/interfaces/kits/napi/BUILD.gn @@ -0,0 +1,62 @@ +# Copyright (c) 2021 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. + +import("//build/ohos.gni") + +ohos_shared_library("huks") { + defines = [ + "L2_STANDARD", + "_HARDWARE_ROOT_KEY_", + "_HUKS_LOG_ENABLE_", + ] + + include_dirs = [ + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "//base/security/huks/frameworks/huks_standard/main/common/include", + "//foundation/ace/napi/interfaces/kits/napi", + "//utils/native/base/include", + "//third_party/node/src", + "include", + ] + + sources = [ + "src/huks_napi.cpp", + "src/huks_napi_agree_key.cpp", + "src/huks_napi_attest_key.cpp", + "src/huks_napi_common.cpp", + "src/huks_napi_decrypt.cpp", + "src/huks_napi_delete_key.cpp", + "src/huks_napi_derive_key.cpp", + "src/huks_napi_encrypt.cpp", + "src/huks_napi_export_key.cpp", + "src/huks_napi_generate_key.cpp", + "src/huks_napi_get_certificate_chain.cpp", + "src/huks_napi_get_key_properties.cpp", + "src/huks_napi_get_sdk_version.cpp", + "src/huks_napi_import_key.cpp", + "src/huks_napi_is_key_exist.cpp", + "src/huks_napi_mac.cpp", + "src/huks_napi_sign.cpp", + "src/huks_napi_unwrap_key.cpp", + "src/huks_napi_verify.cpp", + "src/huks_napi_wrap_key.cpp", + ] + + deps = [ "//foundation/ace/napi:ace_napi" ] + + external_deps = [ "huks_standard:libhukssdk" ] + + relative_install_dir = "module/security" + subsystem_name = "security" + part_name = "huks_standard" +} diff --git a/interfaces/kits/napi/include/huks_napi.h b/interfaces/kits/napi/include/huks_napi.h new file mode 100755 index 0000000000000000000000000000000000000000..b76d968270eb7641c5f99e9cf8655173c57920ab --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi.h @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_NAPI_H +#define HKS_NAPI_H + +#endif \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_agree_key.h b/interfaces/kits/napi/include/huks_napi_agree_key.h new file mode 100755 index 0000000000000000000000000000000000000000..6704791ce22cb9e6bb1fb258f89210b5c5285f83 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_agree_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_AGREE_KEY_H +#define HUKS_NAPI_AGREE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiAgreeKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_AGREE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_attest_key.h b/interfaces/kits/napi/include/huks_napi_attest_key.h new file mode 100755 index 0000000000000000000000000000000000000000..be7074c176346a398437d96b91ad1279772eb031 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_attest_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_ATTEST_KEY_H +#define HUKS_NAPI_ATTEST_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiAttestKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_ATTEST_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_common.h b/interfaces/kits/napi/include/huks_napi_common.h new file mode 100755 index 0000000000000000000000000000000000000000..7c9f4d35d62ba4bfc512cd69fe0f1d4607e0d824 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_common.h @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_COMMON_H +#define HUKS_NAPI_COMMON_H + +#include + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +#include "hks_mem.h" +#include "hks_type.h" + +namespace HuksNapi { +static const std::string HKS_OPTIONS_PROPERTY_PROPERTIES = "properties"; +static const std::string HKS_OPTIONS_PROPERTY_INDATA = "inData"; + +static const std::string HKS_PARAM_PROPERTY_TAG = "tag"; +static const std::string HKS_PARAM_PROPERTY_VALUE = "value"; + +static const std::string HKS_RESULT_PROPERTY_ERRORCODE = "errorCode"; +static const std::string HKS_RESULT_PROPERTY_OUTDATA = "outData"; +static const std::string HKS_RESULT_PRPPERTY_PROPERTIES = "properties"; +static const std::string HKS_RESULT_PRPPERTY_CERTCHAINS = "certChains"; + +static const std::string BUSINESS_ERROR_PROPERTY_CODE = "code"; + +napi_value GetUint8Array(napi_env env, napi_value object, HksBlob &arrayBlob); + +napi_value ParseKeyAlias(napi_env env, napi_value object, HksBlob *&alias); + +napi_value ParseHksParamSet(napi_env env, napi_value object, HksParamSet *¶mSet); + +napi_ref GetCallback(napi_env env, napi_value object); + +napi_value GenerateHksResult(napi_env env, int32_t error); +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size); +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size, const HksParamSet ¶mSet); + +napi_value GenerateStringArray(napi_env env, const struct HksBlob *blob, const uint32_t blobCount); + +void CallAsyncCallback(napi_env env, napi_ref callback, int32_t error, napi_value data); + +inline napi_value GetNull(napi_env env) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_get_null(env, &result)); + return result; +} + +inline napi_value GetInt32(napi_env env, int value) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_int32(env, 1, &result)); + return result; +} + +inline void FreeHksBlob(HksBlob *&blob) +{ + if (blob == nullptr) { + return; + } + + if (blob->data != nullptr) { + HksFree(blob->data); + blob->data = nullptr; + } + blob->size = 0; + + HksFree(blob); + blob = nullptr; +} + +void FreeHksCertChain(HksCertChain *&certChain); +} // namespace HuksNapi + +#endif \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_decrypt.h b/interfaces/kits/napi/include/huks_napi_decrypt.h new file mode 100755 index 0000000000000000000000000000000000000000..f4c9db7921938b3c6eaf3efb312b8edb5970a02c --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_decrypt.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_DECRYPT_H +#define HUKS_NAPI_DECRYPT_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiDecrypt(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_DECRYPT_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_delete_key.h b/interfaces/kits/napi/include/huks_napi_delete_key.h new file mode 100755 index 0000000000000000000000000000000000000000..f5f5f165c66d218bf452b98d324139407dd03854 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_delete_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_DELETE_KEY_H +#define HUKS_NAPI_DELETE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiDeleteKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_DELETE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_derive_key.h b/interfaces/kits/napi/include/huks_napi_derive_key.h new file mode 100755 index 0000000000000000000000000000000000000000..44482bae2b091a45d1389f7b4075b1d889ecc7d6 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_derive_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_DERIVE_KEY_H +#define HUKS_NAPI_DERIVE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiDeriveKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_DERIVE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_encrypt.h b/interfaces/kits/napi/include/huks_napi_encrypt.h new file mode 100755 index 0000000000000000000000000000000000000000..6f81b62dc7f569f427d1d9c078311645d7aabc66 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_encrypt.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_ENCRYPT_H +#define HUKS_NAPI_ENCRYPT_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiEncrypt(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_ENCRYPT_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_export_key.h b/interfaces/kits/napi/include/huks_napi_export_key.h new file mode 100755 index 0000000000000000000000000000000000000000..516786210ab0002c28471c129787cb48b40a4ac7 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_export_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_EXPORT_KEY_H +#define HUKS_NAPI_EXPORT_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiExportKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_EXPORT_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_generate_key.h b/interfaces/kits/napi/include/huks_napi_generate_key.h new file mode 100755 index 0000000000000000000000000000000000000000..7ee5a4e192ee9c30bb7ab3b8098ec1851eb84d39 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_generate_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_GENERATE_KEY_H +#define HUKS_NAPI_GENERATE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiGenerateKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_GENERATE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h b/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h new file mode 100755 index 0000000000000000000000000000000000000000..2bb789a8ac71a3ac59ef463bf2ed6870b725169f --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_GET_CERTIFICATE_CHAIN_H +#define HUKS_NAPI_GET_CERTIFICATE_CHAIN_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiGetCertificateChain(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_GET_CERTIFICATE_CHAIN_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_get_key_properties.h b/interfaces/kits/napi/include/huks_napi_get_key_properties.h new file mode 100755 index 0000000000000000000000000000000000000000..8392b3849dcf1de9b49d9cda4d021271bc6adf58 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_get_key_properties.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_GET_KEY_PROPERTIES_H +#define HUKS_NAPI_GET_KEY_PROPERTIES_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiGetKeyProperties(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_GET_KEY_PROPERTIES_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_get_sdk_version.h b/interfaces/kits/napi/include/huks_napi_get_sdk_version.h new file mode 100755 index 0000000000000000000000000000000000000000..3019cae10bafc30882509d9bfd7984657f259aa1 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_get_sdk_version.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_GET_SDK_VERSION_H +#define HUKS_NAPI_GET_SDK_VERSION_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiGetSdkVersion(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_GET_SDK_VERSION_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_import_key.h b/interfaces/kits/napi/include/huks_napi_import_key.h new file mode 100755 index 0000000000000000000000000000000000000000..5c39290687ffac0da038d84efa8ef5d12c0c9fe0 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_import_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_IMPORT_KEY_H +#define HUKS_NAPI_IMPORT_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiImportKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_IMPORT_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_is_key_exist.h b/interfaces/kits/napi/include/huks_napi_is_key_exist.h new file mode 100755 index 0000000000000000000000000000000000000000..236512bc88395ce26eaed46b951033c88360bf9b --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_is_key_exist.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_IS_KEY_EXIST_H +#define HUKS_NAPI_IS_KEY_EXIST_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiIsKeyExist(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_IS_KEY_EXIST_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_mac.h b/interfaces/kits/napi/include/huks_napi_mac.h new file mode 100755 index 0000000000000000000000000000000000000000..eba2f1755e7f3369e1be704ad695bbbb583ef036 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_mac.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_MAC_H +#define HUKS_NAPI_MAC_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiMac(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_MAC_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_sign.h b/interfaces/kits/napi/include/huks_napi_sign.h new file mode 100755 index 0000000000000000000000000000000000000000..4b83717fddea7458950e65e4aeaca9569a6d3aed --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_sign.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_SIGN_H +#define HUKS_NAPI_SIGN_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiSign(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_SIGN_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_unwrap_key.h b/interfaces/kits/napi/include/huks_napi_unwrap_key.h new file mode 100755 index 0000000000000000000000000000000000000000..9b0c417edfa61212a43b3b72a1d6d716350196e6 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_unwrap_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_UNWRAP_KEY_H +#define HUKS_NAPI_UNWRAP_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiUnwrapKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_UNWRAP_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_verify.h b/interfaces/kits/napi/include/huks_napi_verify.h new file mode 100755 index 0000000000000000000000000000000000000000..1b23ddc297e006cde6ee6fbf4d356d2f67fc4960 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_verify.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_VERIFY_H +#define HUKS_NAPI_VERIFY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiVerify(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_VERIFY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_wrap_key.h b/interfaces/kits/napi/include/huks_napi_wrap_key.h new file mode 100755 index 0000000000000000000000000000000000000000..c946624946a83a9709882e7c9ec94b6e7cccc5f5 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_wrap_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HUKS_NAPI_WRAP_KEY_H +#define HUKS_NAPI_WRAP_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiWrapKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_WRAP_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi.cpp b/interfaces/kits/napi/src/huks_napi.cpp new file mode 100755 index 0000000000000000000000000000000000000000..cb631e7fac4a99182108c96111ecefb4c258741c --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi.cpp @@ -0,0 +1,532 @@ +/* + * Copyright (c) 2021 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 "huks_napi.h" + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +#include "hks_type.h" +#include "huks_napi_agree_key.h" +#include "huks_napi_attest_key.h" +#include "huks_napi_decrypt.h" +#include "huks_napi_delete_key.h" +#include "huks_napi_derive_key.h" +#include "huks_napi_encrypt.h" +#include "huks_napi_export_key.h" +#include "huks_napi_generate_key.h" +#include "huks_napi_get_certificate_chain.h" +#include "huks_napi_get_key_properties.h" +#include "huks_napi_get_sdk_version.h" +#include "huks_napi_import_key.h" +#include "huks_napi_is_key_exist.h" +#include "huks_napi_mac.h" +#include "huks_napi_sign.h" +#include "huks_napi_unwrap_key.h" +#include "huks_napi_verify.h" +#include "huks_napi_wrap_key.h" + +namespace HuksNapi { +inline void AddInt32Property(napi_env env, napi_value object, const char *name, int32_t value) +{ + napi_value property = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, value, &property)); + NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name, property)); +} + +static void AddHksTagPart1(napi_env env, napi_value tag) +{ + /* Invalid TAG */ + AddInt32Property(env, tag, "HKS_TAG_INVALID", HKS_TAG_INVALID); + + /* Base algrithom TAG: 1 - 200 */ + AddInt32Property(env, tag, "HKS_TAG_ALGORITHM", HKS_TAG_ALGORITHM); + AddInt32Property(env, tag, "HKS_TAG_PURPOSE", HKS_TAG_PURPOSE); + AddInt32Property(env, tag, "HKS_TAG_KEY_SIZE", HKS_TAG_KEY_SIZE); + AddInt32Property(env, tag, "HKS_TAG_DIGEST", HKS_TAG_DIGEST); + AddInt32Property(env, tag, "HKS_TAG_PADDING", HKS_TAG_PADDING); + AddInt32Property(env, tag, "HKS_TAG_BLOCK_MODE", HKS_TAG_BLOCK_MODE); + AddInt32Property(env, tag, "HKS_TAG_KEY_TYPE", HKS_TAG_KEY_TYPE); + AddInt32Property(env, tag, "HKS_TAG_ASSOCIATED_DATA", HKS_TAG_ASSOCIATED_DATA); + AddInt32Property(env, tag, "HKS_TAG_NONCE", HKS_TAG_NONCE); + AddInt32Property(env, tag, "HKS_TAG_IV", HKS_TAG_IV); + + /* Key derivation TAG */ + AddInt32Property(env, tag, "HKS_TAG_INFO", HKS_TAG_INFO); + AddInt32Property(env, tag, "HKS_TAG_SALT", HKS_TAG_SALT); + AddInt32Property(env, tag, "HKS_TAG_PWD", HKS_TAG_PWD); + AddInt32Property(env, tag, "HKS_TAG_ITERATION", HKS_TAG_ITERATION); + + AddInt32Property(env, tag, "HKS_TAG_KEY_GENERATE_TYPE", HKS_TAG_KEY_GENERATE_TYPE); + AddInt32Property(env, tag, "HKS_TAG_DERIVE_MAIN_KEY", HKS_TAG_DERIVE_MAIN_KEY); + AddInt32Property(env, tag, "HKS_TAG_DERIVE_FACTOR", HKS_TAG_DERIVE_FACTOR); + AddInt32Property(env, tag, "HKS_TAG_DERIVE_ALG", HKS_TAG_DERIVE_ALG); + AddInt32Property(env, tag, "HKS_TAG_AGREE_ALG", HKS_TAG_AGREE_ALG); + AddInt32Property(env, tag, "HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS", HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS); + AddInt32Property(env, tag, "HKS_TAG_AGREE_PRIVATE_KEY_ALIAS", HKS_TAG_AGREE_PRIVATE_KEY_ALIAS); + AddInt32Property(env, tag, "HKS_TAG_AGREE_PUBLIC_KEY", HKS_TAG_AGREE_PUBLIC_KEY); + + /* + * Key authentication related TAG: 201 - 300 + * + * Start of validity + */ + AddInt32Property(env, tag, "HKS_TAG_ACTIVE_DATETIME", HKS_TAG_ACTIVE_DATETIME); + + /* Date when new "messages" should not be created. */ + AddInt32Property(env, tag, "HKS_TAG_ORIGINATION_EXPIRE_DATETIME", HKS_TAG_ORIGINATION_EXPIRE_DATETIME); + + /* Date when existing "messages" should not be used. */ + AddInt32Property(env, tag, "HKS_TAG_USAGE_EXPIRE_DATETIME", HKS_TAG_USAGE_EXPIRE_DATETIME); + + /* Key creation time */ + AddInt32Property(env, tag, "HKS_TAG_CREATION_DATETIME", HKS_TAG_CREATION_DATETIME); + + /* Other authentication related TAG: 301 - 500 */ + AddInt32Property(env, tag, "HKS_TAG_ALL_USERS", HKS_TAG_ALL_USERS); + AddInt32Property(env, tag, "HKS_TAG_USER_ID", HKS_TAG_USER_ID); + AddInt32Property(env, tag, "HKS_TAG_NO_AUTH_REQUIRED", HKS_TAG_NO_AUTH_REQUIRED); + AddInt32Property(env, tag, "HKS_TAG_USER_AUTH_TYPE", HKS_TAG_USER_AUTH_TYPE); + AddInt32Property(env, tag, "HKS_TAG_AUTH_TIMEOUT", HKS_TAG_AUTH_TIMEOUT); + AddInt32Property(env, tag, "HKS_TAG_AUTH_TOKEN", HKS_TAG_AUTH_TOKEN); + + /* Attestation related TAG: 501 - 600 */ + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_CHALLENGE", HKS_TAG_ATTESTATION_CHALLENGE); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_APPLICATION_ID", HKS_TAG_ATTESTATION_APPLICATION_ID); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_BRAND", HKS_TAG_ATTESTATION_ID_BRAND); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_DEVICE", HKS_TAG_ATTESTATION_ID_DEVICE); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_PRODUCT", HKS_TAG_ATTESTATION_ID_PRODUCT); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_SERIAL", HKS_TAG_ATTESTATION_ID_SERIAL); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_IMEI", HKS_TAG_ATTESTATION_ID_IMEI); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MEID", HKS_TAG_ATTESTATION_ID_MEID); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MANUFACTURER", HKS_TAG_ATTESTATION_ID_MANUFACTURER); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MODEL", HKS_TAG_ATTESTATION_ID_MODEL); + AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_ALIAS", HKS_TAG_ATTESTATION_ID_ALIAS); +} + +static void AddHksTagPart2(napi_env env, napi_value tag) +{ + /* + * Other reserved TAG: 601 - 1000 + * + * Extention TAG: 1001 - 9999 + */ + AddInt32Property(env, tag, "HKS_TAG_IS_KEY_ALIAS", HKS_TAG_IS_KEY_ALIAS); + AddInt32Property(env, tag, "HKS_TAG_KEY_STORAGE_FLAG", HKS_TAG_KEY_STORAGE_FLAG); + AddInt32Property(env, tag, "HKS_TAG_IS_ALLOWED_WRAP", HKS_TAG_IS_ALLOWED_WRAP); + AddInt32Property(env, tag, "HKS_TAG_KEY_WRAP_TYPE", HKS_TAG_KEY_WRAP_TYPE); + AddInt32Property(env, tag, "HKS_TAG_KEY_AUTH_ID", HKS_TAG_KEY_AUTH_ID); + AddInt32Property(env, tag, "HKS_TAG_KEY_ROLE", HKS_TAG_KEY_ROLE); + AddInt32Property(env, tag, "HKS_TAG_KEY_FLAG", HKS_TAG_KEY_FLAG); + AddInt32Property(env, tag, "HKS_TAG_IS_ASYNCHRONIZED", HKS_TAG_IS_ASYNCHRONIZED); + AddInt32Property(env, tag, "HKS_TAG_SECURE_KEY_ALIAS", HKS_TAG_SECURE_KEY_ALIAS); + AddInt32Property(env, tag, "HKS_TAG_SECURE_KEY_UUID", HKS_TAG_SECURE_KEY_UUID); + AddInt32Property(env, tag, "HKS_TAG_KEY_DOMAIN", HKS_TAG_KEY_DOMAIN); + + /* Inner-use TAG: 10001 - 10999 */ + AddInt32Property(env, tag, "HKS_TAG_PROCESS_NAME", HKS_TAG_PROCESS_NAME); + AddInt32Property(env, tag, "HKS_TAG_PACKAGE_NAME", HKS_TAG_PACKAGE_NAME); + AddInt32Property(env, tag, "HKS_TAG_ACCESS_TIME", HKS_TAG_ACCESS_TIME); + AddInt32Property(env, tag, "HKS_TAG_USES_TIME", HKS_TAG_USES_TIME); + AddInt32Property(env, tag, "HKS_TAG_CRYPTO_CTX", HKS_TAG_CRYPTO_CTX); + AddInt32Property(env, tag, "HKS_TAG_KEY", HKS_TAG_KEY); + AddInt32Property(env, tag, "HKS_TAG_KEY_VERSION", HKS_TAG_KEY_VERSION); + AddInt32Property(env, tag, "HKS_TAG_PAYLOAD_LEN", HKS_TAG_PAYLOAD_LEN); + AddInt32Property(env, tag, "HKS_TAG_AE_TAG", HKS_TAG_AE_TAG); + AddInt32Property(env, tag, "HKS_TAG_IS_KEY_HANDLE", HKS_TAG_IS_KEY_HANDLE); + + /* Os version related TAG */ + AddInt32Property(env, tag, "HKS_TAG_OS_VERSION", HKS_TAG_OS_VERSION); + AddInt32Property(env, tag, "HKS_TAG_OS_PATCHLEVEL", HKS_TAG_OS_PATCHLEVEL); + + /* + * Reversed TAGs for SOTER: 11000 - 12000 + * + * Other TAGs: 20001 - N + * TAGs used for paramSetOut + */ + AddInt32Property(env, tag, "HKS_TAG_SYMMETRIC_KEY_DATA", HKS_TAG_SYMMETRIC_KEY_DATA); + AddInt32Property(env, tag, "HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA", HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA); + AddInt32Property(env, tag, "HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA", HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA); +} + +static napi_value CreateHksTag(napi_env env) +{ + napi_value tag = nullptr; + NAPI_CALL(env, napi_create_object(env, &tag)); + + AddHksTagPart1(env, tag); + AddHksTagPart2(env, tag); + + return tag; +} + +static napi_value CreateHksKeySize(napi_env env) +{ + napi_value keySize = nullptr; + NAPI_CALL(env, napi_create_object(env, &keySize)); + + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_512", HKS_RSA_KEY_SIZE_512); + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_768", HKS_RSA_KEY_SIZE_768); + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_1024", HKS_RSA_KEY_SIZE_1024); + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_2048", HKS_RSA_KEY_SIZE_2048); + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_3072", HKS_RSA_KEY_SIZE_3072); + AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_4096", HKS_RSA_KEY_SIZE_4096); + + AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_224", HKS_ECC_KEY_SIZE_224); + AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_256", HKS_ECC_KEY_SIZE_256); + AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_384", HKS_ECC_KEY_SIZE_384); + AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_521", HKS_ECC_KEY_SIZE_521); + + AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_128", HKS_AES_KEY_SIZE_128); + AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_192", HKS_AES_KEY_SIZE_192); + AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_256", HKS_AES_KEY_SIZE_256); + AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_512", HKS_AES_KEY_SIZE_512); + + AddInt32Property(env, keySize, "HKS_CURVE25519_KEY_SIZE_256", HKS_CURVE25519_KEY_SIZE_256); + + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_2048", HKS_DH_KEY_SIZE_2048); + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_3072", HKS_DH_KEY_SIZE_3072); + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_4096", HKS_DH_KEY_SIZE_4096); + + return keySize; +} + +static napi_value CreateHksKeyAlg(napi_env env) +{ + napi_value keyAlg = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyAlg)); + + AddInt32Property(env, keyAlg, "HKS_ALG_RSA", HKS_ALG_RSA); + AddInt32Property(env, keyAlg, "HKS_ALG_ECC", HKS_ALG_ECC); + AddInt32Property(env, keyAlg, "HKS_ALG_DSA", HKS_ALG_DSA); + + AddInt32Property(env, keyAlg, "HKS_ALG_AES", HKS_ALG_AES); + AddInt32Property(env, keyAlg, "HKS_ALG_HMAC", HKS_ALG_HMAC); + AddInt32Property(env, keyAlg, "HKS_ALG_HKDF", HKS_ALG_HKDF); + AddInt32Property(env, keyAlg, "HKS_ALG_PBKDF2", HKS_ALG_PBKDF2); + + AddInt32Property(env, keyAlg, "HKS_ALG_ECDH", HKS_ALG_ECDH); + AddInt32Property(env, keyAlg, "HKS_ALG_X25519", HKS_ALG_X25519); + AddInt32Property(env, keyAlg, "HKS_ALG_ED25519", HKS_ALG_ED25519); + AddInt32Property(env, keyAlg, "HKS_ALG_DH", HKS_ALG_DH); + + return keyAlg; +} + +static napi_value CreateHksKeyPurpose(napi_env env) +{ + napi_value keyPurpose = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyPurpose)); + + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_ENCRYPT", HKS_KEY_PURPOSE_ENCRYPT); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_DECRYPT", HKS_KEY_PURPOSE_DECRYPT); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_SIGN", HKS_KEY_PURPOSE_SIGN); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_VERIFY", HKS_KEY_PURPOSE_VERIFY); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_DERIVE", HKS_KEY_PURPOSE_DERIVE); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_WRAP", HKS_KEY_PURPOSE_WRAP); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_UNWRAP", HKS_KEY_PURPOSE_UNWRAP); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_MAC", HKS_KEY_PURPOSE_MAC); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_AGREE", HKS_KEY_PURPOSE_AGREE); + + return keyPurpose; +} + +static napi_value CreateHksKeyPadding(napi_env env) +{ + napi_value keyPadding = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyPadding)); + + AddInt32Property(env, keyPadding, "HKS_PADDING_NONE", HKS_PADDING_NONE); + AddInt32Property(env, keyPadding, "HKS_PADDING_OAEP", HKS_PADDING_OAEP); + AddInt32Property(env, keyPadding, "HKS_PADDING_PSS", HKS_PADDING_PSS); + AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS1_V1_5", HKS_PADDING_PKCS1_V1_5); + AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS5", HKS_PADDING_PKCS5); + AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS7", HKS_PADDING_PKCS7); + + return keyPadding; +} + +static napi_value CreateHksCipherMode(napi_env env) +{ + napi_value keyCipherMode = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyCipherMode)); + + AddInt32Property(env, keyCipherMode, "HKS_MODE_ECB", HKS_MODE_ECB); + AddInt32Property(env, keyCipherMode, "HKS_MODE_CBC", HKS_MODE_CBC); + AddInt32Property(env, keyCipherMode, "HKS_MODE_CTR", HKS_MODE_CTR); + AddInt32Property(env, keyCipherMode, "HKS_MODE_OFB", HKS_MODE_OFB); + AddInt32Property(env, keyCipherMode, "HKS_MODE_CCM", HKS_MODE_CCM); + AddInt32Property(env, keyCipherMode, "HKS_MODE_GCM", HKS_MODE_GCM); + + return keyCipherMode; +} + +static napi_value CreateHksKeyStorageType(napi_env env) +{ + napi_value keyStorageType = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyStorageType)); + + AddInt32Property(env, keyStorageType, "HKS_STORAGE_TEMP", HKS_STORAGE_TEMP); + AddInt32Property(env, keyStorageType, "HKS_STORAGE_PERSISTENT", HKS_STORAGE_PERSISTENT); + + return keyStorageType; +} + +static void AddHksErrorCodePart1(napi_env env, napi_value errorCode) +{ + AddInt32Property(env, errorCode, "HKS_SUCCESS", HKS_SUCCESS); + AddInt32Property(env, errorCode, "HKS_FAILURE", HKS_FAILURE); + AddInt32Property(env, errorCode, "HKS_ERROR_BAD_STATE", HKS_ERROR_BAD_STATE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ARGUMENT", HKS_ERROR_INVALID_ARGUMENT); + AddInt32Property(env, errorCode, "HKS_ERROR_NOT_SUPPORTED", HKS_ERROR_NOT_SUPPORTED); + AddInt32Property(env, errorCode, "HKS_ERROR_NO_PERMISSION", HKS_ERROR_NO_PERMISSION); + AddInt32Property(env, errorCode, "HKS_ERROR_INSUFFICIENT_DATA", HKS_ERROR_INSUFFICIENT_DATA); + AddInt32Property(env, errorCode, "HKS_ERROR_BUFFER_TOO_SMALL", HKS_ERROR_BUFFER_TOO_SMALL); + AddInt32Property(env, errorCode, "HKS_ERROR_INSUFFICIENT_MEMORY", HKS_ERROR_INSUFFICIENT_MEMORY); + AddInt32Property(env, errorCode, "HKS_ERROR_COMMUNICATION_FAILURE", HKS_ERROR_COMMUNICATION_FAILURE); + AddInt32Property(env, errorCode, "HKS_ERROR_STORAGE_FAILURE", HKS_ERROR_STORAGE_FAILURE); + AddInt32Property(env, errorCode, "HKS_ERROR_HARDWARE_FAILURE", HKS_ERROR_HARDWARE_FAILURE); + AddInt32Property(env, errorCode, "HKS_ERROR_ALREADY_EXISTS", HKS_ERROR_ALREADY_EXISTS); + AddInt32Property(env, errorCode, "HKS_ERROR_NOT_EXIST", HKS_ERROR_NOT_EXIST); + AddInt32Property(env, errorCode, "HKS_ERROR_NULL_POINTER", HKS_ERROR_NULL_POINTER); + AddInt32Property(env, errorCode, "HKS_ERROR_FILE_SIZE_FAIL", HKS_ERROR_FILE_SIZE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_READ_FILE_FAIL", HKS_ERROR_READ_FILE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PUBLIC_KEY", HKS_ERROR_INVALID_PUBLIC_KEY); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PRIVATE_KEY", HKS_ERROR_INVALID_PRIVATE_KEY); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_INFO", HKS_ERROR_INVALID_KEY_INFO); + AddInt32Property(env, errorCode, "HKS_ERROR_HASH_NOT_EQUAL", HKS_ERROR_HASH_NOT_EQUAL); + AddInt32Property(env, errorCode, "HKS_ERROR_MALLOC_FAIL", HKS_ERROR_MALLOC_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_WRITE_FILE_FAIL", HKS_ERROR_WRITE_FILE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_REMOVE_FILE_FAIL", HKS_ERROR_REMOVE_FILE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_OPEN_FILE_FAIL", HKS_ERROR_OPEN_FILE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CLOSE_FILE_FAIL", HKS_ERROR_CLOSE_FILE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_MAKE_DIR_FAIL", HKS_ERROR_MAKE_DIR_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_FILE", HKS_ERROR_INVALID_KEY_FILE); + AddInt32Property(env, errorCode, "HKS_ERROR_IPC_MSG_FAIL", HKS_ERROR_IPC_MSG_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_REQUEST_OVERFLOWS", HKS_ERROR_REQUEST_OVERFLOWS); + AddInt32Property(env, errorCode, "HKS_ERROR_PARAM_NOT_EXIST", HKS_ERROR_PARAM_NOT_EXIST); + AddInt32Property(env, errorCode, "HKS_ERROR_CRYPTO_ENGINE_ERROR", HKS_ERROR_CRYPTO_ENGINE_ERROR); + AddInt32Property(env, errorCode, "HKS_ERROR_COMMUNICATION_TIMEOUT", HKS_ERROR_COMMUNICATION_TIMEOUT); + AddInt32Property(env, errorCode, "HKS_ERROR_IPC_INIT_FAIL", HKS_ERROR_IPC_INIT_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_IPC_DLOPEN_FAIL", HKS_ERROR_IPC_DLOPEN_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_EFUSE_READ_FAIL", HKS_ERROR_EFUSE_READ_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST", HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST); + AddInt32Property( + env, errorCode, "HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL", HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL); +} + +static void AddHksErrorCodePart2(napi_env env, napi_value errorCode) +{ + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_ALG_FAIL", HKS_ERROR_CHECK_GET_ALG_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL", HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_PADDING_FAIL", HKS_ERROR_CHECK_GET_PADDING_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_PURPOSE_FAIL", HKS_ERROR_CHECK_GET_PURPOSE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_DIGEST_FAIL", HKS_ERROR_CHECK_GET_DIGEST_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_MODE_FAIL", HKS_ERROR_CHECK_GET_MODE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_NONCE_FAIL", HKS_ERROR_CHECK_GET_NONCE_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_AAD_FAIL", HKS_ERROR_CHECK_GET_AAD_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_IV_FAIL", HKS_ERROR_CHECK_GET_IV_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_AE_TAG_FAIL", HKS_ERROR_CHECK_GET_AE_TAG_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_SALT_FAIL", HKS_ERROR_CHECK_GET_SALT_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_ITERATION_FAIL", HKS_ERROR_CHECK_GET_ITERATION_FAIL); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ALGORITHM", HKS_ERROR_INVALID_ALGORITHM); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_SIZE", HKS_ERROR_INVALID_KEY_SIZE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PADDING", HKS_ERROR_INVALID_PADDING); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PURPOSE", HKS_ERROR_INVALID_PURPOSE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_MODE", HKS_ERROR_INVALID_MODE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_DIGEST", HKS_ERROR_INVALID_DIGEST); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_SIGNATURE_SIZE", HKS_ERROR_INVALID_SIGNATURE_SIZE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_IV", HKS_ERROR_INVALID_IV); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_AAD", HKS_ERROR_INVALID_AAD); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_NONCE", HKS_ERROR_INVALID_NONCE); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_AE_TAG", HKS_ERROR_INVALID_AE_TAG); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_SALT", HKS_ERROR_INVALID_SALT); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ITERATION", HKS_ERROR_INVALID_ITERATION); + AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_OPERATION", HKS_ERROR_INVALID_OPERATION); + + AddInt32Property(env, errorCode, "HKS_ERROR_INTERNAL_ERROR", HKS_ERROR_INTERNAL_ERROR); + AddInt32Property(env, errorCode, "HKS_ERROR_UNKNOWN_ERROR", HKS_ERROR_UNKNOWN_ERROR); +} + +static napi_value CreateHksErrorCode(napi_env env) +{ + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_object(env, &errorCode)); + + AddHksErrorCodePart1(env, errorCode); + AddHksErrorCodePart2(env, errorCode); + + return errorCode; +} + +static napi_value CreateHksKeyType(napi_env env) +{ + napi_value keyType = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyType)); + + AddInt32Property(env, keyType, "HKS_KEY_TYPE_RSA_PUBLIC_KEY", HKS_KEY_TYPE_RSA_PUBLIC_KEY); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_RSA_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR); + + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P256_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P256_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P384_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P384_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P521_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P521_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR); + + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ED25519_PUBLIC_KEY", HKS_KEY_TYPE_ED25519_PUBLIC_KEY); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_ED25519_KEYPAIR", HKS_KEY_TYPE_ED25519_KEYPAIR); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_X25519_PUBLIC_KEY", HKS_KEY_TYPE_X25519_PUBLIC_KEY); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_X25519_KEYPAIR", HKS_KEY_TYPE_X25519_KEYPAIR); + + AddInt32Property(env, keyType, "HKS_KEY_TYPE_AES", HKS_KEY_TYPE_AES); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_CHACHA20", HKS_KEY_TYPE_CHACHA20); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_CHACHA20_POLY1305", HKS_KEY_TYPE_CHACHA20_POLY1305); + + AddInt32Property(env, keyType, "HKS_KEY_TYPE_HMAC", HKS_KEY_TYPE_HMAC); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_HKDF", HKS_KEY_TYPE_HKDF); + AddInt32Property(env, keyType, "HKS_KEY_TYPE_PBKDF2", HKS_KEY_TYPE_PBKDF2); + + return keyType; +} + +static napi_value CreateHksKeyDigest(napi_env env) +{ + napi_value keyDisgest = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyDisgest)); + + AddInt32Property(env, keyDisgest, "HKS_DIGEST_NONE", HKS_DIGEST_NONE); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_MD5", HKS_DIGEST_MD5); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA1", HKS_DIGEST_SHA1); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA224", HKS_DIGEST_SHA224); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA256", HKS_DIGEST_SHA256); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA384", HKS_DIGEST_SHA384); + AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA512", HKS_DIGEST_SHA512); + + return keyDisgest; +} + +static napi_value CreateHksKeyGenerateType(napi_env env) +{ + napi_value keyGenerateType = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyGenerateType)); + + AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_DEFAULT", HKS_KEY_GENERATE_TYPE_DEFAULT); + AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_DERIVE", HKS_KEY_GENERATE_TYPE_DERIVE); + AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_AGREE", HKS_KEY_GENERATE_TYPE_AGREE); + + return keyGenerateType; +} + +static napi_value CreateHksKeyFlag(napi_env env) +{ + napi_value keyFlag = nullptr; + NAPI_CALL(env, napi_create_object(env, &keyFlag)); + + AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_IMPORT_KEY", HKS_KEY_FLAG_IMPORT_KEY); + AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_GENERATE_KEY", HKS_KEY_FLAG_GENERATE_KEY); + + return keyFlag; +} + +static napi_value CreateHksTagType(napi_env env) +{ + napi_value tagType = nullptr; + NAPI_CALL(env, napi_create_object(env, &tagType)); + + AddInt32Property(env, tagType, "HKS_TAG_TYPE_INVALID", HKS_TAG_TYPE_INVALID); + AddInt32Property(env, tagType, "HKS_TAG_TYPE_INT", HKS_TAG_TYPE_INT); + AddInt32Property(env, tagType, "HKS_TAG_TYPE_UINT", HKS_TAG_TYPE_UINT); + AddInt32Property(env, tagType, "HKS_TAG_TYPE_ULONG", HKS_TAG_TYPE_ULONG); + AddInt32Property(env, tagType, "HKS_TAG_TYPE_BOOL", HKS_TAG_TYPE_BOOL); + AddInt32Property(env, tagType, "HKS_TAG_TYPE_BYTES", HKS_TAG_TYPE_BYTES); + + return tagType; +} +} // namespace HuksNapi + +using namespace HuksNapi; + +extern "C" { +static napi_value HuksNapiRegister(napi_env env, napi_value exports) +{ + napi_value errorCode = CreateHksErrorCode(env); + napi_value keyType = CreateHksKeyType(env); + napi_value keyPurpose = CreateHksKeyPurpose(env); + napi_value keyDigest = CreateHksKeyDigest(env); + napi_value keyPadding = CreateHksKeyPadding(env); + napi_value keyCipherMode = CreateHksCipherMode(env); + napi_value keySize = CreateHksKeySize(env); + napi_value keyAlg = CreateHksKeyAlg(env); + napi_value keyGenerateType = CreateHksKeyGenerateType(env); + napi_value keyFlag = CreateHksKeyFlag(env); + napi_value keyStorageType = CreateHksKeyStorageType(env); + napi_value tagType = CreateHksTagType(env); + napi_value tag = CreateHksTag(env); + + napi_property_descriptor desc[] = { + DECLARE_NAPI_PROPERTY("HksErrorCode", errorCode), + DECLARE_NAPI_PROPERTY("HksKeyType", keyType), + DECLARE_NAPI_PROPERTY("HksKeyPurpose", keyPurpose), + DECLARE_NAPI_PROPERTY("HksKeyDigest", keyDigest), + DECLARE_NAPI_PROPERTY("HksKeyPadding", keyPadding), + DECLARE_NAPI_PROPERTY("HksCipherMode", keyCipherMode), + DECLARE_NAPI_PROPERTY("HksKeySize", keySize), + DECLARE_NAPI_PROPERTY("HksKeyAlg", keyAlg), + DECLARE_NAPI_PROPERTY("HksKeyGenerateType", keyGenerateType), + DECLARE_NAPI_PROPERTY("HksKeyFlag", keyFlag), + DECLARE_NAPI_PROPERTY("HksKeyStorageType", keyStorageType), + DECLARE_NAPI_PROPERTY("HksTagType", tagType), + DECLARE_NAPI_PROPERTY("HksTag", tag), + + DECLARE_NAPI_FUNCTION("generateKey", HuksNapiGenerateKey), + DECLARE_NAPI_FUNCTION("deleteKey", HuksNapiDeleteKey), + DECLARE_NAPI_FUNCTION("encrypt", HuksNapiEncrypt), + DECLARE_NAPI_FUNCTION("decrypt", HuksNapiDecrypt), + DECLARE_NAPI_FUNCTION("getSdkVersion", HuksNapiGetSdkVersion), + DECLARE_NAPI_FUNCTION("importKey", HuksNapiImportKey), + DECLARE_NAPI_FUNCTION("exportKey", HuksNapiExportKey), + DECLARE_NAPI_FUNCTION("getKeyProperties", HuksNapiGetKeyProperties), + DECLARE_NAPI_FUNCTION("isKeyExist", HuksNapiIsKeyExist), + DECLARE_NAPI_FUNCTION("sign", HuksNapiSign), + DECLARE_NAPI_FUNCTION("verify", HuksNapiVerify), + DECLARE_NAPI_FUNCTION("agreeKey", HuksNapiAgreeKey), + DECLARE_NAPI_FUNCTION("deriveKey", HuksNapiDeriveKey), + DECLARE_NAPI_FUNCTION("mac", HuksNapiMac), + DECLARE_NAPI_FUNCTION("attestKey", HuksNapiAttestKey), + DECLARE_NAPI_FUNCTION("getCertificateChain", HuksNapiGetCertificateChain), + DECLARE_NAPI_FUNCTION("wrapKey", HuksNapiWrapKey), + DECLARE_NAPI_FUNCTION("unwrapKey", HuksNapiUnwrapKey), + }; + NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); + return exports; +} + +static napi_module g_module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = HuksNapiRegister, + .nm_modname = "huks", + .nm_priv = ((void *)0), + .reserved = {0}, +}; + +__attribute__((constructor)) void RegisterModule(void) +{ + napi_module_register(&g_module); +} +} diff --git a/interfaces/kits/napi/src/huks_napi_agree_key.cpp b/interfaces/kits/napi/src/huks_napi_agree_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..4f607ce80f9f911ea5fc5b9727027af88f375daf --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_agree_key.cpp @@ -0,0 +1,247 @@ +/* + * Copyright (c) 2021 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 "huks_napi_agree_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_AGREE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_AGREE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_AGREED_KEY_SIZE = 512; +} // namespace + +struct AgreeKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *peerPublicKey = nullptr; + struct HksBlob *agreedKey = nullptr; +}; +using AgreeKeyAsyncContext = AgreeKeyAsyncContext_t *; + +static AgreeKeyAsyncContext CreateAgreeKeyAsyncContext() +{ + AgreeKeyAsyncContext context = (AgreeKeyAsyncContext)HksMalloc(sizeof(AgreeKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(AgreeKeyAsyncContext_t), 0, sizeof(AgreeKeyAsyncContext_t)); + } + return context; +} + +static void DeleteAgreeKeyAsyncContext(napi_env env, AgreeKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->peerPublicKey != nullptr) { + if (context->peerPublicKey->data != nullptr && context->peerPublicKey->size != 0) { + (void)memset_s(context->peerPublicKey->data, context->peerPublicKey->size, 0, context->peerPublicKey->size); + } + FreeHksBlob(context->peerPublicKey); + } + + if (context->agreedKey != nullptr) { + if (context->agreedKey->data != nullptr && context->agreedKey->size != 0) { + (void)memset_s(context->agreedKey->data, context->agreedKey->size, 0, context->agreedKey->size); + } + FreeHksBlob(context->agreedKey); + } + + HksFree(context); +} + +static napi_value AgreeKeyParseParams(napi_env env, napi_callback_info info, AgreeKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_AGREE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_AGREE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_AGREE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->peerPublicKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->peerPublicKey == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->peerPublicKey); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value AgreeKeyWriteResult(napi_env env, AgreeKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->agreedKey != nullptr) ? context->agreedKey->data : nullptr), + (context->result == HKS_SUCCESS && context->agreedKey != nullptr) ? context->agreedKey->size : 0); +} + +static napi_value AgreeKeyAsyncWork(napi_env env, AgreeKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "agreeKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + AgreeKeyAsyncContext context = static_cast(data); + + context->agreedKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->agreedKey != nullptr) { + context->agreedKey->data = (uint8_t *)HksMalloc(HKS_MAX_AGREED_KEY_SIZE); + context->agreedKey->size = HKS_MAX_AGREED_KEY_SIZE; + } + + context->result = + HksAgreeKey(context->paramSet, context->keyAlias, context->peerPublicKey, context->agreedKey); + }, + [](napi_env env, napi_status status, void *data) { + AgreeKeyAsyncContext context = static_cast(data); + napi_value result = AgreeKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteAgreeKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteAgreeKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiAgreeKey(napi_env env, napi_callback_info info) +{ + AgreeKeyAsyncContext context = CreateAgreeKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = AgreeKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteAgreeKeyAsyncContext(env, context); + return nullptr; + } + + result = AgreeKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteAgreeKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_attest_key.cpp b/interfaces/kits/napi/src/huks_napi_attest_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..022fcf54d10435f967143981d3bf72830a2d2774 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_attest_key.cpp @@ -0,0 +1,219 @@ +/* + * Copyright (c) 2021 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 "huks_napi_attest_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_ATTEST_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_ATTEST_KEY_MAX_ARGS = 3; +} // namespace + +struct AttestKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksCertChain *certChain = nullptr; +}; +using AttestKeyAsyncContext = AttestKeyAsyncContext_t *; + +static AttestKeyAsyncContext CreateAttestKeyAsyncContext() +{ + AttestKeyAsyncContext context = (AttestKeyAsyncContext)HksMalloc(sizeof(AttestKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(AttestKeyAsyncContext_t), 0, sizeof(AttestKeyAsyncContext_t)); + } + return context; +} + +static void DeleteAttestKeyAsyncContext(napi_env env, AttestKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->certChain != nullptr) { + FreeHksCertChain(context->certChain); + } + + HksFree(context); +} + +static napi_value AttestKeyParseParams(napi_env env, napi_callback_info info, AttestKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_ATTEST_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_ATTEST_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_ATTEST_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value AttestKeyWriteResult(napi_env env, AttestKeyAsyncContext context) +{ + napi_value result = GenerateHksResult(env, context->result, nullptr, 0); + if (result != nullptr) { + napi_value certChains = GenerateStringArray(env, context->certChain->certs, context->certChain->certsCount); + if (certChains != nullptr) { + napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_CERTCHAINS.c_str(), certChains); + } + } + return result; +} + +static napi_value AttestKeyAsyncWork(napi_env env, AttestKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "attestKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + AttestKeyAsyncContext context = static_cast(data); + + context->certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (context->certChain != nullptr) { + context->certChain->certs = nullptr; + context->certChain->certsCount = 0; + } + + context->result = HksAttestKey(context->keyAlias, context->paramSet, context->certChain); + }, + [](napi_env env, napi_status status, void *data) { + AttestKeyAsyncContext context = static_cast(data); + napi_value result = AttestKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteAttestKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteAttestKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiAttestKey(napi_env env, napi_callback_info info) +{ + AttestKeyAsyncContext context = CreateAttestKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = AttestKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteAttestKeyAsyncContext(env, context); + return nullptr; + } + + result = AttestKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteAttestKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_common.cpp b/interfaces/kits/napi/src/huks_napi_common.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ca77caff9c49b88318f77eb25dac7b0a1b28f82e --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_common.cpp @@ -0,0 +1,394 @@ +/* + * Copyright (c) 2021 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 "huks_napi_common.h" + +#include "securec.h" + +#include "hks_log.h" +#include "hks_param.h" +#include "hks_type.h" + +namespace HuksNapi { +namespace { +constexpr int HKS_MAX_DATA_LEN = 0x40000000; +constexpr size_t ASYNCCALLBACK_ARGC = 2; +} // namespace + +napi_value ParseKeyAlias(napi_env env, napi_value object, HksBlob *&alias) +{ + char *data = (char *)HksMalloc(HKS_MAX_KEY_ALIAS_LEN); + if (data == nullptr) { + napi_throw_error(env, NULL, "could not alloc memory"); + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + (void)memset_s(data, HKS_MAX_KEY_ALIAS_LEN, 0x0, HKS_MAX_KEY_ALIAS_LEN); + + size_t length = 0; + napi_status status = napi_get_value_string_utf8(env, object, data, HKS_MAX_KEY_ALIAS_LEN, &length); + if (status != napi_ok) { + HksFree(data); + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get string"); + return nullptr; + } + + alias = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (alias == nullptr) { + HksFree(data); + napi_throw_error(env, NULL, "could not alloc memory"); + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + alias->data = (uint8_t *)data; + alias->size = (uint32_t)(length & UINT32_MAX); + + return GetInt32(env, 0); +} + +napi_value GetUint8Array(napi_env env, napi_value object, HksBlob &arrayBlob) +{ + napi_typedarray_type arrayType; + napi_value arrayBuffer = nullptr; + size_t length = 0; + size_t offset = 0; + void *rawData = nullptr; + + NAPI_CALL( + env, napi_get_typedarray_info(env, object, &arrayType, &length, (void **)&rawData, &arrayBuffer, &offset)); + NAPI_ASSERT(env, arrayType == napi_uint8_array, "it's not uint8 array"); + + if (length > HKS_MAX_DATA_LEN) { + HKS_LOG_E("data len is too large, len = %x", length); + return nullptr; + } + + arrayBlob.data = (uint8_t *)HksMalloc(length); + if (arrayBlob.data == nullptr) { + return nullptr; + } + (void)memcpy_s(arrayBlob.data, length, rawData, length); + arrayBlob.size = (uint32_t)length; + + return GetInt32(env, 0); +} + +static napi_value GetHksParam(napi_env env, napi_value object, HksParam ¶m) +{ + napi_value tag = nullptr; + NAPI_CALL(env, napi_get_named_property(env, object, HKS_PARAM_PROPERTY_TAG.c_str(), &tag)); + NAPI_CALL(env, napi_get_value_uint32(env, tag, ¶m.tag)); + + napi_value value = nullptr; + NAPI_CALL(env, napi_get_named_property(env, object, HKS_PARAM_PROPERTY_VALUE.c_str(), &value)); + + napi_value result = nullptr; + + switch (param.tag & HKS_TAG_TYPE_MASK) { + case HKS_TAG_TYPE_INT: + NAPI_CALL(env, napi_get_value_int32(env, value, ¶m.int32Param)); + result = GetInt32(env, 0); + break; + case HKS_TAG_TYPE_UINT: + NAPI_CALL(env, napi_get_value_uint32(env, value, ¶m.uint32Param)); + result = GetInt32(env, 0); + break; + case HKS_TAG_TYPE_ULONG: + NAPI_CALL(env, napi_get_value_int64(env, value, (int64_t *)¶m.uint64Param)); + result = GetInt32(env, 0); + break; + case HKS_TAG_TYPE_BOOL: + NAPI_CALL(env, napi_get_value_bool(env, value, ¶m.boolParam)); + result = GetInt32(env, 0); + break; + case HKS_TAG_TYPE_BYTES: + result = GetUint8Array(env, value, param.blob); + if (result == nullptr) { + HKS_LOG_E("get uint8 array fail."); + } else { + HKS_LOG_D("tag %x, len %x, data %d", param.tag, param.blob.size, param.blob.data); + } + break; + default: + HKS_LOG_E("invalid tag value %x", param.tag); + break; + } + + return result; +} + +napi_value ParseHksParamSet(napi_env env, napi_value object, HksParamSet *¶mSet) +{ + if (HksInitParamSet(¶mSet) != HKS_SUCCESS) { + napi_throw_error(env, NULL, "native error"); + HKS_LOG_E("init paramset failed"); + return nullptr; + } + + size_t index = 0; + bool hasNextElement = false; + napi_value result = nullptr; + while ((napi_has_element(env, object, index, &hasNextElement) == napi_ok) && hasNextElement) { + napi_value element = nullptr; + NAPI_CALL(env, napi_get_element(env, object, index, &element)); + + HksParam param = {0}; + result = GetHksParam(env, element, param); + if (result == nullptr) { + HKS_LOG_E("GetHksParam failed."); + HksFreeParamSet(¶mSet); + return nullptr; + } + + if (HksAddParams(paramSet, ¶m, 1) != HKS_SUCCESS) { + HKS_LOG_E("HksAddParams failed."); + HksFreeParamSet(¶mSet); + return nullptr; + } + index++; + } + + if (HksBuildParamSet(¶mSet) != HKS_SUCCESS) { + HKS_LOG_E("HksBuildParamSet failed."); + HksFreeParamSet(¶mSet); + return nullptr; + } + + return GetInt32(env, 0); +} + +napi_ref GetCallback(napi_env env, napi_value object) +{ + napi_valuetype valueType = napi_undefined; + napi_status status = napi_typeof(env, object, &valueType); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get object type"); + return nullptr; + } + + if (valueType != napi_function) { + HKS_LOG_E("invalid type"); + return nullptr; + } + + napi_ref ref = nullptr; + status = napi_create_reference(env, object, 1, &ref); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not create reference"); + return nullptr; + } + return ref; +} + +static napi_value GenerateAarrayBuffer(napi_env env, uint8_t *data, uint32_t size) +{ + napi_value outBuffer = nullptr; + uint8_t *buffer = (uint8_t *)HksMalloc(size); + if (buffer != nullptr) { + memcpy_s(buffer, size, data, size); + + napi_status status = napi_create_external_arraybuffer( + env, buffer, size, [](napi_env env, void *data, void *hint) { HksFree(data); }, nullptr, &outBuffer); + if (status != napi_ok) { + HksFree(buffer); + GET_AND_THROW_LAST_ERROR((env)); + return nullptr; + } + } + return outBuffer; +} + +static napi_value GenerateHksParam(napi_env env, const HksParam ¶m) +{ + napi_value hksParam = nullptr; + NAPI_CALL(env, napi_create_object(env, &hksParam)); + + napi_value tag = nullptr; + NAPI_CALL(env, napi_create_uint32(env, param.tag, &tag)); + NAPI_CALL(env, napi_set_named_property(env, hksParam, HKS_PARAM_PROPERTY_TAG.c_str(), tag)); + + napi_value value = nullptr; + switch (param.tag & HKS_TAG_TYPE_MASK) { + case HKS_TAG_TYPE_INT: + NAPI_CALL(env, napi_create_int32(env, param.int32Param, &value)); + break; + case HKS_TAG_TYPE_UINT: + NAPI_CALL(env, napi_create_uint32(env, param.uint32Param, &value)); + break; + case HKS_TAG_TYPE_ULONG: + NAPI_CALL(env, napi_create_int64(env, param.uint64Param, &value)); + break; + case HKS_TAG_TYPE_BOOL: + NAPI_CALL(env, napi_get_boolean(env, param.boolParam, &value)); + break; + case HKS_TAG_TYPE_BYTES: + value = GenerateAarrayBuffer(env, param.blob.data, param.blob.size); + break; + default: + value = GetNull(env); + break; + } + NAPI_CALL(env, napi_set_named_property(env, hksParam, HKS_PARAM_PROPERTY_VALUE.c_str(), value)); + + return hksParam; +} + +static napi_value GenerateHksParamArray(napi_env env, const HksParamSet ¶mSet) +{ + napi_value paramArray = nullptr; + NAPI_CALL(env, napi_create_array(env, ¶mArray)); + + for (uint32_t i = 0; i < paramSet.paramsCnt; i++) { + napi_value element = nullptr; + element = GenerateHksParam(env, paramSet.params[i]); + napi_set_element(env, paramArray, i, element); + } + + return paramArray; +} + +napi_value GenerateHksResult(napi_env env, int32_t error) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_object(env, &result)); + + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_int32(env, error, &errorCode)); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_ERRORCODE.c_str(), errorCode)); + + napi_value outData = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); + + napi_value properties = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); + + return result; +} + +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_object(env, &result)); + + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_int32(env, error, &errorCode)); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_ERRORCODE.c_str(), errorCode)); + + napi_value outData = nullptr; + if (data != nullptr && size != 0) { + napi_value outBuffer = GenerateAarrayBuffer(env, data, size); + if (outBuffer != nullptr) { + NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, size, outBuffer, 0, &outData)); + } + } else { + outData = GetNull(env); + } + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); + + napi_value properties = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); + + return result; +} + +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size, const HksParamSet ¶mSet) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_object(env, &result)); + + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_int32(env, error, &errorCode)); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_ERRORCODE.c_str(), errorCode)); + + napi_value outData = nullptr; + if (data != nullptr && size != 0) { + napi_value outBuffer = GenerateAarrayBuffer(env, data, size); + if (outBuffer != nullptr) { + NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, size, outBuffer, 0, &outData)); + } + } else { + outData = GetNull(env); + } + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); + + napi_value properties = GenerateHksParamArray(env, paramSet); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); + + return result; +} + +static napi_value GenerateBusinessError(napi_env env, int32_t errorCode) +{ + napi_value businessError = nullptr; + NAPI_CALL(env, napi_create_object(env, &businessError)); + + napi_value code = nullptr; + NAPI_CALL(env, napi_create_int32(env, errorCode, &code)); + NAPI_CALL(env, napi_set_named_property(env, businessError, BUSINESS_ERROR_PROPERTY_CODE.c_str(), code)); + + return businessError; +} + +void CallAsyncCallback(napi_env env, napi_ref callback, int32_t error, napi_value data) +{ + napi_value businessError = GenerateBusinessError(env, error); + + napi_value params[ASYNCCALLBACK_ARGC] = { businessError, data }; + + napi_value func = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callback, &func)); + + napi_value recv = nullptr; + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &recv)); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, func, ASYNCCALLBACK_ARGC, params, &result)); +} + +napi_value GenerateStringArray(napi_env env, const struct HksBlob *blob, const uint32_t blobCount) +{ + if (blobCount == 0 || blob == nullptr) { + return nullptr; + } + napi_value array = nullptr; + NAPI_CALL(env, napi_create_array(env, &array)); + for (uint32_t i = 0; i < blobCount; i++) { + napi_value element = nullptr; + napi_create_string_latin1(env, (const char *)blob[i].data, blob[i].size, &element); + napi_set_element(env, array, i, element); + } + return array; +} + +void FreeHksCertChain(HksCertChain *&certChain) +{ + if (certChain == nullptr) { + return; + } + + if (certChain->certsCount > 0 && certChain->certs != nullptr) { + for (uint32_t i = 0; i < certChain->certsCount; i++) { + if (certChain->certs[i].data != nullptr) { + HksFree(certChain->certs[i].data); + } + } + } + + HksFree(certChain); + certChain = nullptr; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_decrypt.cpp b/interfaces/kits/napi/src/huks_napi_decrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..cf0f75c87111ded4a5f2f6d63d464101edc1ba5b --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_decrypt.cpp @@ -0,0 +1,243 @@ +/* + * Copyright (c) 2021 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 "huks_napi_decrypt.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_DECRYPT_MIN_ARGS = 2; +constexpr int HUKS_NAPI_DECRYPT_MAX_ARGS = 3; +} // namespace + +struct DecryptAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *cipherText = nullptr; + struct HksBlob *plainText = nullptr; +}; +using DecryptAsyncContext = DecryptAsyncContext_t *; + +static DecryptAsyncContext CreateDecryptAsyncContext() +{ + DecryptAsyncContext context = (DecryptAsyncContext)HksMalloc(sizeof(DecryptAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(DecryptAsyncContext_t), 0, sizeof(DecryptAsyncContext_t)); + } + return context; +} + +static void DeleteDecryptAsyncContext(napi_env env, DecryptAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->cipherText != nullptr) { + if (context->cipherText->data != nullptr && context->cipherText->size != 0) { + (void)memset_s(context->cipherText->data, context->cipherText->size, 0, context->cipherText->size); + } + FreeHksBlob(context->cipherText); + } + + if (context->plainText != nullptr) { + if (context->plainText->data != nullptr && context->plainText->size != 0) { + (void)memset_s(context->plainText->data, context->plainText->size, 0, context->plainText->size); + } + FreeHksBlob(context->plainText); + } + + HksFree(context); +} + +static napi_value DecryptParseParams(napi_env env, napi_callback_info info, DecryptAsyncContext context) +{ + size_t argc = HUKS_NAPI_DECRYPT_MAX_ARGS; + napi_value argv[HUKS_NAPI_DECRYPT_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_DECRYPT_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->cipherText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->cipherText == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->cipherText); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value DecryptKeyWriteResult(napi_env env, DecryptAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->plainText != nullptr) ? context->plainText->data : nullptr), + (context->result == HKS_SUCCESS && context->plainText != nullptr) ? context->plainText->size : 0); +} + +static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "decryptAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + DecryptAsyncContext context = static_cast(data); + + context->plainText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->plainText != NULL) { + context->plainText->data = (uint8_t *)HksMalloc(context->cipherText->size); + context->plainText->size = context->cipherText->size; + } + + context->result = HksDecrypt(context->keyAlias, context->paramSet, context->cipherText, context->plainText); + }, + [](napi_env env, napi_status status, void *data) { + DecryptAsyncContext context = static_cast(data); + napi_value result = DecryptKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteDecryptAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteDecryptAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiDecrypt(napi_env env, napi_callback_info info) +{ + DecryptAsyncContext context = CreateDecryptAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = DecryptParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteDecryptAsyncContext(env, context); + return nullptr; + } + + result = DecryptAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteDecryptAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_delete_key.cpp b/interfaces/kits/napi/src/huks_napi_delete_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..93586fc2635dc516b52fe0634d8e40c016f3a4d2 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_delete_key.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2021 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 "huks_napi_delete_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_DELETE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_DELETE_KEY_MAX_ARGS = 3; +} // namespace + +struct DeleteKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; +}; +using DeleteKeyAsyncContext = DeleteKeyAsyncContext_t *; + +static DeleteKeyAsyncContext CreateDeleteKeyAsyncContext() +{ + DeleteKeyAsyncContext context = (DeleteKeyAsyncContext)HksMalloc(sizeof(DeleteKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(DeleteKeyAsyncContext_t), 0, sizeof(DeleteKeyAsyncContext_t)); + } + return context; +} + +static void DeleteDeleteKeyAsyncContext(napi_env env, DeleteKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + HksFree(context); +} + +static napi_value DeleteKeyParseParams(napi_env env, napi_callback_info info, DeleteKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_DELETE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_DELETE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_DELETE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value DeleteKeyWriteResult(napi_env env, DeleteKeyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value DeleteKeyAsyncWork(napi_env env, DeleteKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "deleteKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + DeleteKeyAsyncContext context = static_cast(data); + + context->result = HksDeleteKey(context->keyAlias, context->paramSet); + }, + [](napi_env env, napi_status status, void *data) { + DeleteKeyAsyncContext context = static_cast(data); + napi_value result = DeleteKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteDeleteKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteDeleteKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiDeleteKey(napi_env env, napi_callback_info info) +{ + DeleteKeyAsyncContext context = CreateDeleteKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = DeleteKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteDeleteKeyAsyncContext(env, context); + return nullptr; + } + + result = DeleteKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteDeleteKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_derive_key.cpp b/interfaces/kits/napi/src/huks_napi_derive_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..9019f847c6749a38db0be56a4ccd7c00f10db723 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_derive_key.cpp @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2021 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 "huks_napi_derive_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_DERIVE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_DERIVE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_DERIVED_KEY_SIZE = 512; +} // namespace + +struct DeriveKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *derivedKey = nullptr; +}; +using DeriveKeyAsyncContext = DeriveKeyAsyncContext_t *; + +static DeriveKeyAsyncContext CreateDeriveKeyAsyncContext() +{ + DeriveKeyAsyncContext context = (DeriveKeyAsyncContext)HksMalloc(sizeof(DeriveKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(DeriveKeyAsyncContext_t), 0, sizeof(DeriveKeyAsyncContext_t)); + } + return context; +} + +static void DeleteDeriveKeyAsyncContext(napi_env env, DeriveKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->derivedKey != nullptr) { + if (context->derivedKey->data != nullptr && context->derivedKey->size != 0) { + (void)memset_s(context->derivedKey->data, context->derivedKey->size, 0, context->derivedKey->size); + } + FreeHksBlob(context->derivedKey); + } + + HksFree(context); +} + +static napi_value DeriveKeyParseParams(napi_env env, napi_callback_info info, DeriveKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_DERIVE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_DERIVE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_DERIVE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value DeriveKeyWriteResult(napi_env env, DeriveKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->derivedKey != nullptr) ? context->derivedKey->data : nullptr), + (context->result == HKS_SUCCESS && context->derivedKey != nullptr) ? context->derivedKey->size : 0); +} + +static napi_value DeriveKeyAsyncWork(napi_env env, DeriveKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "deriveKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + DeriveKeyAsyncContext context = static_cast(data); + + context->derivedKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->derivedKey != nullptr) { + context->derivedKey->data = (uint8_t *)HksMalloc(HKS_MAX_DERIVED_KEY_SIZE); + context->derivedKey->size = HKS_MAX_DERIVED_KEY_SIZE; + } + + context->result = HksDeriveKey(context->paramSet, context->keyAlias, context->derivedKey); + }, + [](napi_env env, napi_status status, void *data) { + DeriveKeyAsyncContext context = static_cast(data); + napi_value result = DeriveKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteDeriveKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteDeriveKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiDeriveKey(napi_env env, napi_callback_info info) +{ + DeriveKeyAsyncContext context = CreateDeriveKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = DeriveKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteDeriveKeyAsyncContext(env, context); + return nullptr; + } + + result = DeriveKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteDeriveKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_encrypt.cpp b/interfaces/kits/napi/src/huks_napi_encrypt.cpp new file mode 100755 index 0000000000000000000000000000000000000000..32ad084701c8e9b4f472d9eed1808ee09e7dbbc2 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_encrypt.cpp @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2021 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 "huks_napi_encrypt.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_ENCRYPT_MIN_ARGS = 2; +constexpr int HUKS_NAPI_ENCRYPT_MAX_ARGS = 3; + +constexpr int HKS_CIPHER_TEXT_DEFALT_PADDING = 512; +} // namespace + +struct EncryptAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *plainText = nullptr; + struct HksBlob *cipherText = nullptr; +}; +using EncryptAsyncContext = EncryptAsyncContext_t *; + +static EncryptAsyncContext CreateEncryptAsyncContext() +{ + EncryptAsyncContext context = (EncryptAsyncContext)HksMalloc(sizeof(EncryptAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(EncryptAsyncContext_t), 0, sizeof(EncryptAsyncContext_t)); + } + return context; +} + +static void DeleteEncryptAsyncContext(napi_env env, EncryptAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->plainText != nullptr) { + if (context->plainText->data != nullptr && context->plainText->size != 0) { + (void)memset_s(context->plainText->data, context->plainText->size, 0, context->plainText->size); + } + FreeHksBlob(context->plainText); + } + + if (context->cipherText != nullptr) { + if (context->cipherText->data != nullptr && context->cipherText->size != 0) { + (void)memset_s(context->cipherText->data, context->cipherText->size, 0, context->cipherText->size); + } + FreeHksBlob(context->cipherText); + } + + HksFree(context); +} + +static napi_value EncryptParseParams(napi_env env, napi_callback_info info, EncryptAsyncContext context) +{ + size_t argc = HUKS_NAPI_ENCRYPT_MAX_ARGS; + napi_value argv[HUKS_NAPI_ENCRYPT_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_ENCRYPT_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->plainText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->plainText == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->plainText); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value EncryptWriteResult(napi_env env, EncryptAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->cipherText != nullptr) ? context->cipherText->data : nullptr), + (context->result == HKS_SUCCESS && context->cipherText != nullptr) ? context->cipherText->size : 0); +} + +static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "encryptAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + EncryptAsyncContext context = static_cast(data); + + context->cipherText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->cipherText != NULL) { + context->cipherText->data = + (uint8_t *)HksMalloc(context->plainText->size + HKS_CIPHER_TEXT_DEFALT_PADDING); + context->cipherText->size = context->plainText->size + HKS_CIPHER_TEXT_DEFALT_PADDING; + } + + context->result = HksEncrypt(context->keyAlias, context->paramSet, context->plainText, context->cipherText); + }, + [](napi_env env, napi_status status, void *data) { + EncryptAsyncContext context = static_cast(data); + napi_value result = EncryptWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteEncryptAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteEncryptAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiEncrypt(napi_env env, napi_callback_info info) +{ + EncryptAsyncContext context = CreateEncryptAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = EncryptParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteEncryptAsyncContext(env, context); + return nullptr; + } + + result = EncryptAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteEncryptAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_export_key.cpp b/interfaces/kits/napi/src/huks_napi_export_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..fb49cb113bf8e180b25935c93000e2eb91ff42a4 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_export_key.cpp @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2021 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 "huks_napi_export_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_EXPORT_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_EXPORT_KEY_MAX_ARGS = 3; +} // namespace + +struct ExportKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *key = nullptr; +}; +using ExportKeyAsyncContext = ExportKeyAsyncContext_t *; + +static ExportKeyAsyncContext CreateExportKeyAsyncContext() +{ + ExportKeyAsyncContext context = (ExportKeyAsyncContext)HksMalloc(sizeof(ExportKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(ExportKeyAsyncContext_t), 0, sizeof(ExportKeyAsyncContext_t)); + } + return context; +} + +static void DeleteExportKeyAsyncContext(napi_env env, ExportKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->key != nullptr) { + if (context->key->data != nullptr && context->key->size != 0) { + (void)memset_s(context->key->data, context->key->size, 0, context->key->size); + } + FreeHksBlob(context->key); + } + + HksFree(context); +} + +static napi_value ExportKeyParseParams(napi_env env, napi_callback_info info, ExportKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_EXPORT_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_EXPORT_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_EXPORT_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value ExportKeyWriteResult(napi_env env, ExportKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->key != nullptr) ? context->key->data : nullptr), + (context->result == HKS_SUCCESS && context->key != nullptr) ? context->key->size : 0); +} + +static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "exportKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + ExportKeyAsyncContext context = static_cast(data); + + context->key = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->key != NULL) { + context->key->data = (uint8_t *)HksMalloc(MAX_KEY_SIZE); + context->key->size = MAX_KEY_SIZE; + } + + context->result = HksExportPublicKey(context->keyAlias, context->paramSet, context->key); + }, + [](napi_env env, napi_status status, void *data) { + ExportKeyAsyncContext context = static_cast(data); + napi_value result = ExportKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteExportKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteExportKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiExportKey(napi_env env, napi_callback_info info) +{ + ExportKeyAsyncContext context = CreateExportKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = ExportKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteExportKeyAsyncContext(env, context); + return nullptr; + } + + result = ExportKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteExportKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_generate_key.cpp b/interfaces/kits/napi/src/huks_napi_generate_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..c50828d4c214c76b216f0932bf36858fc9d58215 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_generate_key.cpp @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2021 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 "huks_napi_generate_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_GETNRATEKEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_GENERATEKEY_MAX_ARGS = 3; +} // namespace + +struct GenerateKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSetIn = nullptr; + struct HksParamSet *paramSetOut = nullptr; +}; +using GenerateKeyAsyncContext = GenerateKeyAsyncContext_t *; + +static GenerateKeyAsyncContext CreateGenerateKeyAsyncContext() +{ + GenerateKeyAsyncContext context = (GenerateKeyAsyncContext)HksMalloc(sizeof(GenerateKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(GenerateKeyAsyncContext_t), 0, sizeof(GenerateKeyAsyncContext_t)); + } + return context; +} + +static void DeleteGenerateKeyAsyncContext(napi_env env, GenerateKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSetIn != nullptr) { + HksFreeParamSet(&context->paramSetIn); + } + + if (context->paramSetOut != nullptr) { + HksFreeParamSet(&context->paramSetOut); + } + + HksFree(context); +} + +static napi_value GenerateKeyParseParams(napi_env env, napi_callback_info info, GenerateKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_GENERATEKEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_GENERATEKEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_GETNRATEKEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get properties"); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSetIn); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value GenerateKeyWriteResult(napi_env env, GenerateKeyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value GenerateKeyAsyncWork(napi_env env, GenerateKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "generateKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + GenerateKeyAsyncContext context = static_cast(data); + + context->result = HksGenerateKey(context->keyAlias, context->paramSetIn, context->paramSetOut); + }, + [](napi_env env, napi_status status, void *data) { + GenerateKeyAsyncContext context = static_cast(data); + napi_value result = GenerateKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteGenerateKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteGenerateKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiGenerateKey(napi_env env, napi_callback_info info) +{ + GenerateKeyAsyncContext context = CreateGenerateKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = GenerateKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteGenerateKeyAsyncContext(env, context); + return nullptr; + } + + result = GenerateKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteGenerateKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp b/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp new file mode 100755 index 0000000000000000000000000000000000000000..f273f0e63a8e886a214860c0a33f8f54455ddeec --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2021 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 "huks_napi_get_certificate_chain.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_GET_CERTIFICATE_CHAIN_MIN_ARGS = 2; +constexpr int HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS = 3; +} // namespace + +struct GetCertificateChainAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksCertChain *certChain = nullptr; +}; +using GetCertificateChainAsyncContext = GetCertificateChainAsyncContext_t *; + +static GetCertificateChainAsyncContext CreateGetCertificateChainAsyncContext() +{ + GetCertificateChainAsyncContext context = + (GetCertificateChainAsyncContext)HksMalloc(sizeof(GetCertificateChainAsyncContext_t)); + if (context != nullptr) { + (void)memset_s( + context, sizeof(GetCertificateChainAsyncContext_t), 0, sizeof(GetCertificateChainAsyncContext_t)); + } + return context; +} + +static void DeleteGetCertificateChainAsyncContext(napi_env env, GetCertificateChainAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->certChain != nullptr) { + FreeHksCertChain(context->certChain); + } + + HksFree(context); +} + +static napi_value GetCertificateChainParseParams( + napi_env env, napi_callback_info info, GetCertificateChainAsyncContext context) +{ + size_t argc = HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS; + napi_value argv[HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_GET_CERTIFICATE_CHAIN_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value GetCertificateChainWriteResult(napi_env env, GetCertificateChainAsyncContext context) +{ + napi_value result = GenerateHksResult(env, context->result, nullptr, 0); + if (result != nullptr) { + napi_value certChains = GenerateStringArray(env, context->certChain->certs, context->certChain->certsCount); + if (certChains != nullptr) { + napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_CERTCHAINS.c_str(), certChains); + } + } + return result; +} + +static napi_value GetCertificateChainAsyncWork(napi_env env, GetCertificateChainAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "getCertificateChainAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + GetCertificateChainAsyncContext context = static_cast(data); + + context->certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (context->certChain != nullptr) { + context->certChain->certs = nullptr; + context->certChain->certsCount = 0; + } + + context->result = HksGetCertificateChain(context->keyAlias, context->paramSet, context->certChain); + }, + [](napi_env env, napi_status status, void *data) { + GetCertificateChainAsyncContext context = static_cast(data); + napi_value result = GetCertificateChainWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteGetCertificateChainAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteGetCertificateChainAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiGetCertificateChain(napi_env env, napi_callback_info info) +{ + GetCertificateChainAsyncContext context = CreateGetCertificateChainAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = GetCertificateChainParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteGetCertificateChainAsyncContext(env, context); + return nullptr; + } + + result = GetCertificateChainAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteGetCertificateChainAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp b/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp new file mode 100755 index 0000000000000000000000000000000000000000..92085e54272823eebf4ab0d2b232bee627dabdeb --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2021 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 "huks_napi_get_key_properties.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_GET_KEY_PROPERTIES_MIN_ARGS = 2; +constexpr int HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS = 3; + +constexpr int HKS_DEFAULT_OUTPARAMSET_SIZE = 2048; +} // namespace + +struct GetKeyPropertiesAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSetIn = nullptr; + struct HksParamSet *paramSetOut = nullptr; +}; +using GetKeyPropertiesAsyncContext = GetKeyPropertiesAsyncContext_t *; + +static GetKeyPropertiesAsyncContext CreateGetKeyPropertiesAsyncContext() +{ + GetKeyPropertiesAsyncContext context = + (GetKeyPropertiesAsyncContext)HksMalloc(sizeof(GetKeyPropertiesAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(GetKeyPropertiesAsyncContext_t), 0, sizeof(GetKeyPropertiesAsyncContext_t)); + } + return context; +} + +static void DeleteGetKeyPropertiesAsyncContext(napi_env env, GetKeyPropertiesAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSetIn != nullptr) { + HksFreeParamSet(&context->paramSetIn); + } + + if (context->paramSetOut != nullptr) { + HksFreeParamSet(&context->paramSetOut); + } + + HksFree(context); +} + +static napi_value GetKeyPropertiesParseParams( + napi_env env, napi_callback_info info, GetKeyPropertiesAsyncContext context) +{ + size_t argc = HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS; + napi_value argv[HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_GET_KEY_PROPERTIES_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get properties"); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSetIn); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value GetKeyPropertiesWriteResult(napi_env env, GetKeyPropertiesAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0, *context->paramSetOut); +} + +static napi_value GetKeyPropertiesAsyncWork(napi_env env, GetKeyPropertiesAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "getKeyPropertiesAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + GetKeyPropertiesAsyncContext context = static_cast(data); + + context->paramSetOut = (struct HksParamSet *)HksMalloc(HKS_DEFAULT_OUTPARAMSET_SIZE); + if (context->paramSetOut) { + context->paramSetOut->paramSetSize = HKS_DEFAULT_OUTPARAMSET_SIZE; + } + + context->result = HksGetKeyParamSet(context->keyAlias, context->paramSetIn, context->paramSetOut); + }, + [](napi_env env, napi_status status, void *data) { + GetKeyPropertiesAsyncContext context = static_cast(data); + napi_value result = GetKeyPropertiesWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteGetKeyPropertiesAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteGetKeyPropertiesAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiGetKeyProperties(napi_env env, napi_callback_info info) +{ + GetKeyPropertiesAsyncContext context = CreateGetKeyPropertiesAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = GetKeyPropertiesParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteGetKeyPropertiesAsyncContext(env, context); + return nullptr; + } + + result = GetKeyPropertiesAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteGetKeyPropertiesAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_get_sdk_version.cpp b/interfaces/kits/napi/src/huks_napi_get_sdk_version.cpp new file mode 100755 index 0000000000000000000000000000000000000000..99aad3090e0d6d9b242daa865152fdc2c3ea98c4 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_get_sdk_version.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2021 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 "huks_napi_get_sdk_version.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" + +namespace HuksNapi { +namespace { +constexpr uint32_t MAX_SDK_VERSION_SIZE = 64; +} + +napi_value HuksNapiGetSdkVersion(napi_env env, napi_callback_info info) +{ + HksBlob *sdkVersion = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (sdkVersion == nullptr) { + return nullptr; + } + + sdkVersion->data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE); + if (sdkVersion->data == nullptr) { + HksFree(sdkVersion); + return nullptr; + } + + sdkVersion->size = MAX_SDK_VERSION_SIZE; + + int32_t result = HksGetSdkVersion(sdkVersion); + if (result != HKS_SUCCESS) { + HksFree(sdkVersion); + return nullptr; + } + + napi_value version = nullptr; + NAPI_CALL(env, napi_create_string_latin1(env, (const char *)sdkVersion->data, NAPI_AUTO_LENGTH, &version)); + return version; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_import_key.cpp b/interfaces/kits/napi/src/huks_napi_import_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ce001bc4f4d4bcfa5d305c467b8fdfd3fb555f2e --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_import_key.cpp @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2021 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 "huks_napi_import_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_IMPORT_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_IMPORT_KEY_MAX_ARGS = 3; +} // namespace + +struct ImportKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *key = nullptr; +}; +using ImportKeyAsyncContext = ImportKeyAsyncContext_t *; + +static ImportKeyAsyncContext CreateImportKeyAsyncContext() +{ + ImportKeyAsyncContext context = (ImportKeyAsyncContext)HksMalloc(sizeof(ImportKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(ImportKeyAsyncContext_t), 0, sizeof(ImportKeyAsyncContext_t)); + } + return context; +} + +static void DeleteImportKeyAsyncContext(napi_env env, ImportKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->key != nullptr) { + if (context->key->data != nullptr && context->key->size != 0) { + (void)memset_s(context->key->data, context->key->size, 0, context->key->size); + } + FreeHksBlob(context->key); + } + + HksFree(context); +} + +static napi_value ImportKeyParseParams(napi_env env, napi_callback_info info, ImportKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_IMPORT_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_IMPORT_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_IMPORT_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->key = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->key == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->key); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value ImportKeyWriteResult(napi_env env, ImportKeyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value ImportKeyAsyncWork(napi_env env, ImportKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "importKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + ImportKeyAsyncContext context = static_cast(data); + + context->result = HksImportKey(context->keyAlias, context->paramSet, context->key); + }, + [](napi_env env, napi_status status, void *data) { + ImportKeyAsyncContext context = static_cast(data); + napi_value result = ImportKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteImportKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteImportKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiImportKey(napi_env env, napi_callback_info info) +{ + ImportKeyAsyncContext context = CreateImportKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = ImportKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteImportKeyAsyncContext(env, context); + return nullptr; + } + + result = ImportKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteImportKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp b/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp new file mode 100755 index 0000000000000000000000000000000000000000..67587bcbf508d2e12cb5b554c8022a1a2a42ed59 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2021 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 "huks_napi_is_key_exist.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_IS_KEY_EXIST_MIN_ARGS = 2; +constexpr int HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS = 3; +} // namespace + +struct IsKeyExistAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; +}; +using IsKeyExistAsyncContext = IsKeyExistAsyncContext_t *; + +static IsKeyExistAsyncContext CreateIsKeyExistAsyncContext() +{ + IsKeyExistAsyncContext context = (IsKeyExistAsyncContext)HksMalloc(sizeof(IsKeyExistAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(IsKeyExistAsyncContext_t), 0, sizeof(IsKeyExistAsyncContext_t)); + } + return context; +} + +static void DeleteIsKeyExistAsyncContext(napi_env env, IsKeyExistAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + HksFree(context); +} + +static napi_value IsKeyExistParseParams(napi_env env, napi_callback_info info, IsKeyExistAsyncContext context) +{ + size_t argc = HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS; + napi_value argv[HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_IS_KEY_EXIST_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get properties"); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value IsKeyExistWriteResult(napi_env env, IsKeyExistAsyncContext context) +{ + napi_value isKeyExist = nullptr; + if (context->result == HKS_SUCCESS) { + NAPI_CALL(env, napi_get_boolean(env, true, &isKeyExist)); + } else { + NAPI_CALL(env, napi_get_boolean(env, false, &isKeyExist)); + } + return isKeyExist; +} + +static napi_value IsKeyExistAsyncWork(napi_env env, IsKeyExistAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "isKeyExistAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + IsKeyExistAsyncContext context = static_cast(data); + + context->result = HksKeyExist(context->keyAlias, context->paramSet); + }, + [](napi_env env, napi_status status, void *data) { + IsKeyExistAsyncContext context = static_cast(data); + napi_value result = IsKeyExistWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteIsKeyExistAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteIsKeyExistAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } +} + +napi_value HuksNapiIsKeyExist(napi_env env, napi_callback_info info) +{ + IsKeyExistAsyncContext context = CreateIsKeyExistAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = IsKeyExistParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteIsKeyExistAsyncContext(env, context); + return nullptr; + } + + result = IsKeyExistAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteIsKeyExistAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_mac.cpp b/interfaces/kits/napi/src/huks_napi_mac.cpp new file mode 100755 index 0000000000000000000000000000000000000000..dc68a7018465ad38c0704c1c0c97a95488dd192a --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_mac.cpp @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2021 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 "huks_napi_mac.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_AGREE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_AGREE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_MAC_SIZE = 512; +} // namespace + +struct MacAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *mac = nullptr; +}; +using MacAsyncContext = MacAsyncContext_t *; + +static MacAsyncContext CreateMacAsyncContext() +{ + MacAsyncContext context = (MacAsyncContext)HksMalloc(sizeof(MacAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(MacAsyncContext_t), 0, sizeof(MacAsyncContext_t)); + } + return context; +} + +static void DeleteMacAsyncContext(napi_env env, MacAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->mac != nullptr) { + if (context->mac->data != nullptr && context->mac->size != 0) { + (void)memset_s(context->mac->data, context->mac->size, 0, context->mac->size); + } + FreeHksBlob(context->mac); + } + + HksFree(context); +} + +static napi_value MacParseParams(napi_env env, napi_callback_info info, MacAsyncContext context) +{ + size_t argc = HUKS_NAPI_AGREE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_AGREE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_AGREE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value MacWriteResult(napi_env env, MacAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->mac != nullptr) ? context->mac->data : nullptr), + (context->result == HKS_SUCCESS && context->mac != nullptr) ? context->mac->size : 0); +} + +static napi_value MacAsyncWork(napi_env env, MacAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "macAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + MacAsyncContext context = static_cast(data); + + context->mac = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->mac != nullptr) { + context->mac->data = (uint8_t *)HksMalloc(HKS_MAX_MAC_SIZE); + context->mac->size = HKS_MAX_MAC_SIZE; + } + + context->result = HksMac(context->keyAlias, context->paramSet, context->srcData, context->mac); + }, + [](napi_env env, napi_status status, void *data) { + MacAsyncContext context = static_cast(data); + napi_value result = MacWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteMacAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteMacAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiMac(napi_env env, napi_callback_info info) +{ + MacAsyncContext context = CreateMacAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = MacParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteMacAsyncContext(env, context); + return nullptr; + } + + result = MacAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteMacAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_sign.cpp b/interfaces/kits/napi/src/huks_napi_sign.cpp new file mode 100755 index 0000000000000000000000000000000000000000..127874bfdd8e21c001c61621655bdda11d3e37c0 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_sign.cpp @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2021 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 "huks_napi_sign.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_SIGN_MIN_ARGS = 2; +constexpr int HUKS_NAPI_SIGN_MAX_ARGS = 3; + +constexpr int HKS_MAX_SIGNATURE_SIZE = 512; +} // namespace + +struct SignAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *signature = nullptr; +}; +using SignAsyncContext = SignAsyncContext_t *; + +static SignAsyncContext CreateSignAsyncContext() +{ + SignAsyncContext context = (SignAsyncContext)HksMalloc(sizeof(SignAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(SignAsyncContext_t), 0, sizeof(SignAsyncContext_t)); + } + return context; +} + +static void DeleteSignAsyncContext(napi_env env, SignAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->signature != nullptr) { + if (context->signature->data != nullptr && context->signature->size != 0) { + (void)memset_s(context->signature->data, context->signature->size, 0, context->signature->size); + } + FreeHksBlob(context->signature); + } + + HksFree(context); +} + +static napi_value SignParseParams(napi_env env, napi_callback_info info, SignAsyncContext context) +{ + size_t argc = HUKS_NAPI_SIGN_MAX_ARGS; + napi_value argv[HUKS_NAPI_SIGN_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_SIGN_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value SignWriteResult(napi_env env, SignAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->signature != nullptr) ? context->signature->data : nullptr), + (context->result == HKS_SUCCESS && context->signature != nullptr) ? context->signature->size : 0); +} + +static napi_value SignAsyncWork(napi_env env, SignAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "signAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + SignAsyncContext context = static_cast(data); + + context->signature = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->signature != NULL) { + context->signature->data = (uint8_t *)HksMalloc(HKS_MAX_SIGNATURE_SIZE); + context->signature->size = HKS_MAX_SIGNATURE_SIZE; + } + + context->result = HksSign(context->keyAlias, context->paramSet, context->srcData, context->signature); + }, + [](napi_env env, napi_status status, void *data) { + SignAsyncContext context = static_cast(data); + napi_value result = SignWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteSignAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteSignAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiSign(napi_env env, napi_callback_info info) +{ + SignAsyncContext context = CreateSignAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = SignParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteSignAsyncContext(env, context); + return nullptr; + } + + result = SignAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteSignAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp b/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..b5ea6e78f1b1abad351df1527416ca16fa508734 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2021 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 "huks_napi_unwrap_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_WRAP_KEY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_WRAP_KEY_MAX_ARGS = 4; +} // namespace + +struct UnwrapKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *targetKeyAlias = nullptr; + struct HksBlob *wrappedData = nullptr; + struct HksParamSet *paramSet = nullptr; +}; +using UnwrapKeyAsyncContext = UnwrapKeyAsyncContext_t *; + +static UnwrapKeyAsyncContext CreateUnwrapKeyAsyncContext() +{ + UnwrapKeyAsyncContext context = (UnwrapKeyAsyncContext)HksMalloc(sizeof(UnwrapKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(UnwrapKeyAsyncContext_t), 0, sizeof(UnwrapKeyAsyncContext_t)); + } + return context; +} + +static void DeleteUnwrapKeyAsyncContext(napi_env env, UnwrapKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->targetKeyAlias != nullptr) { + FreeHksBlob(context->targetKeyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->wrappedData != nullptr) { + if (context->wrappedData->data != nullptr && context->wrappedData->size != 0) { + (void)memset_s(context->wrappedData->data, context->wrappedData->size, 0, context->wrappedData->size); + } + FreeHksBlob(context->wrappedData); + } + + HksFree(context); +} + +static napi_value UnwrapKeyParseOptions(napi_env env, napi_value options, UnwrapKeyAsyncContext context) +{ + napi_value result = nullptr; + + napi_value properties = nullptr; + napi_status status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->wrappedData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->wrappedData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->wrappedData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + return GetInt32(env, 0); +} + +static napi_value UnwrapKeyParseParams(napi_env env, napi_callback_info info, UnwrapKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_WRAP_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_WRAP_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_WRAP_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = ParseKeyAlias(env, argv[index], context->targetKeyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get target alias"); + return nullptr; + } + + index++; + result = UnwrapKeyParseOptions(env, argv[index], context); + if (result == nullptr) { + HKS_LOG_E("could not parse options"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value UnwrapKeyWriteResult(napi_env env, UnwrapKeyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value UnwrapKeyAsyncWork(napi_env env, UnwrapKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "unwrapKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + UnwrapKeyAsyncContext context = static_cast(data); + + context->result = + HksUnwrapKey(context->keyAlias, context->targetKeyAlias, context->wrappedData, context->paramSet); + }, + [](napi_env env, napi_status status, void *data) { + UnwrapKeyAsyncContext context = static_cast(data); + napi_value result = UnwrapKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteUnwrapKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteUnwrapKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiUnwrapKey(napi_env env, napi_callback_info info) +{ + UnwrapKeyAsyncContext context = CreateUnwrapKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = UnwrapKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteUnwrapKeyAsyncContext(env, context); + return nullptr; + } + + result = UnwrapKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteUnwrapKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_verify.cpp b/interfaces/kits/napi/src/huks_napi_verify.cpp new file mode 100755 index 0000000000000000000000000000000000000000..aeabf768b2f5389b4978c068796ce6545df6eb2c --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_verify.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (c) 2021 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 "huks_napi_verify.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_VERIFY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_VERIFY_MAX_ARGS = 4; +} // namespace + +struct VerifyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *signature = nullptr; +}; +using VerifyAsyncContext = VerifyAsyncContext_t *; + +static VerifyAsyncContext CreateVerifyAsyncContext() +{ + VerifyAsyncContext context = (VerifyAsyncContext)HksMalloc(sizeof(VerifyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(VerifyAsyncContext_t), 0, sizeof(VerifyAsyncContext_t)); + } + return context; +} + +static void DeleteVerifyAsyncContext(napi_env env, VerifyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->signature != nullptr) { + if (context->signature->data != nullptr && context->signature->size != 0) { + (void)memset_s(context->signature->data, context->signature->size, 0, context->signature->size); + } + FreeHksBlob(context->signature); + } + + HksFree(context); +} + +static napi_value VerifyParseOptions(napi_env env, napi_value options, VerifyAsyncContext context) +{ + napi_value result = nullptr; + + napi_value properties = nullptr; + napi_status status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + return GetInt32(env, 0); +} + +static napi_value VerifyParseParams(napi_env env, napi_callback_info info, VerifyAsyncContext context) +{ + size_t argc = HUKS_NAPI_VERIFY_MAX_ARGS; + napi_value argv[HUKS_NAPI_VERIFY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_VERIFY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = VerifyParseOptions(env, argv[index], context); + if (result == nullptr) { + HKS_LOG_E("could not parse options"); + return nullptr; + } + + index++; + context->signature = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->signature == nullptr) { + return nullptr; + } + result = GetUint8Array(env, argv[index], *context->signature); + if (result == nullptr) { + HKS_LOG_E("could not get signature"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value VerifyWriteResult(napi_env env, VerifyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value VerifyAsyncWork(napi_env env, VerifyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "verifyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + VerifyAsyncContext context = static_cast(data); + + context->result = HksVerify(context->keyAlias, context->paramSet, context->srcData, context->signature); + }, + [](napi_env env, napi_status status, void *data) { + VerifyAsyncContext context = static_cast(data); + napi_value result = VerifyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteVerifyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteVerifyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiVerify(napi_env env, napi_callback_info info) +{ + VerifyAsyncContext context = CreateVerifyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = VerifyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteVerifyAsyncContext(env, context); + return nullptr; + } + + result = VerifyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteVerifyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_wrap_key.cpp b/interfaces/kits/napi/src/huks_napi_wrap_key.cpp new file mode 100755 index 0000000000000000000000000000000000000000..689c9ab533444173a2b38366b9f5df92dcfdf817 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_wrap_key.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2021 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 "huks_napi_wrap_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_UNWRAP_KEY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_UNWRAP_KEY_MAX_ARGS = 4; + +constexpr int HKS_MAX_WRAPPED_DATA_SIZE = 2048; +} // namespace + +struct WrapKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *targetKeyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *wrappedData = nullptr; +}; +using WrapKeyAsyncContext = WrapKeyAsyncContext_t *; + +static WrapKeyAsyncContext CreateWrapKeyAsyncContext() +{ + WrapKeyAsyncContext context = (WrapKeyAsyncContext)HksMalloc(sizeof(WrapKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(WrapKeyAsyncContext_t), 0, sizeof(WrapKeyAsyncContext_t)); + } + return context; +} + +static void DeleteWrapKeyAsyncContext(napi_env env, WrapKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->targetKeyAlias != nullptr) { + FreeHksBlob(context->targetKeyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->wrappedData != nullptr) { + if (context->wrappedData->data != nullptr && context->wrappedData->size != 0) { + (void)memset_s(context->wrappedData->data, context->wrappedData->size, 0, context->wrappedData->size); + } + FreeHksBlob(context->wrappedData); + } + + HksFree(context); +} + +static napi_value WrapKeyParseParams(napi_env env, napi_callback_info info, WrapKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_UNWRAP_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_UNWRAP_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_UNWRAP_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = ParseKeyAlias(env, argv[index], context->targetKeyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get target alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value WrapKeyWriteResult(napi_env env, WrapKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->wrappedData != nullptr) ? context->wrappedData->data : nullptr), + (context->result == HKS_SUCCESS && context->wrappedData != nullptr) ? context->wrappedData->size : 0); +} + +static napi_value WrapKeyAsyncWork(napi_env env, WrapKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "wrapKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + WrapKeyAsyncContext context = static_cast(data); + + context->wrappedData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->wrappedData != nullptr) { + context->wrappedData->data = (uint8_t *)HksMalloc(HKS_MAX_WRAPPED_DATA_SIZE); + context->wrappedData->size = HKS_MAX_WRAPPED_DATA_SIZE; + } + + context->result = + HksWrapKey(context->keyAlias, context->targetKeyAlias, context->paramSet, context->wrappedData); + }, + [](napi_env env, napi_status status, void *data) { + WrapKeyAsyncContext context = static_cast(data); + napi_value result = WrapKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteWrapKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteWrapKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiWrapKey(napi_env env, napi_callback_info info) +{ + WrapKeyAsyncContext context = CreateWrapKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = WrapKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteWrapKeyAsyncContext(env, context); + return nullptr; + } + + result = WrapKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteWrapKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/ohos.build b/ohos.build index 999365260da849a33dd5cb310ef6f02a6c609fbf..4f7b394d59a5800ff8d9d3b7a851ba67e5a90173 100755 --- a/ohos.build +++ b/ohos.build @@ -20,10 +20,15 @@ "module_list": [ "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", "//base/security/huks/services/huks_standard:huks_service", - "//base/security/huks/services/huks_standard/huks_service/main/os_dependency/sa/sa_profile:huks_sa_profile" + "//base/security/huks/services/huks_standard/huks_service/main/os_dependency/sa/sa_profile:huks_sa_profile", + "//base/security/huks/interfaces/kits/napi:huks" ], "test_list": [ - "//base/security/huks:huks_sdk_test" + "//base/security/huks:huks_sdk_test", + "//base/security/huks/services/huks_standard/huks_service/main/test/unittest:huks_multithread_test", + "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test", + "//base/security/huks/test/stability:huks_stability_test", + "//base/security/huks/test/fuzz:huks_fuzz_test" ] } } diff --git a/services/huks_standard/BUILD.gn b/services/huks_standard/BUILD.gn index 1a56ab3471cd922f4b8367972af2f4973af5a6e4..4b040effcc625a168b649e8166c9091a63e07fc2 100755 --- a/services/huks_standard/BUILD.gn +++ b/services/huks_standard/BUILD.gn @@ -41,7 +41,7 @@ ohos_shared_library("huks_service") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] } diff --git a/services/huks_standard/huks_engine/main/core/src/hks_core_service.c b/services/huks_standard/huks_engine/main/core/src/hks_core_service.c index 38f061aef9538ae87bba1ade020db8a17914540d..54ca0abe405b7a9ca1975c5505bfa4b44a395493 100755 --- a/services/huks_standard/huks_engine/main/core/src/hks_core_service.c +++ b/services/huks_standard/huks_engine/main/core/src/hks_core_service.c @@ -305,6 +305,8 @@ static int32_t SignVerifyAuth(const struct HksKeyNode *keyNode, const struct Hks return HksAuth(HKS_AUTH_ID_SIGN_VERIFY_RSA, keyNode, paramSet); } else if (algParam->uint32Param == HKS_ALG_ECC) { return HksAuth(HKS_AUTH_ID_SIGN_VERIFY_ECC, keyNode, paramSet); + } else if (algParam->uint32Param == HKS_ALG_DSA) { + return HKS_SUCCESS; } else if (algParam->uint32Param == HKS_ALG_ED25519) { return HKS_SUCCESS; } else { @@ -313,7 +315,7 @@ static int32_t SignVerifyAuth(const struct HksKeyNode *keyNode, const struct Hks } static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const struct HksBlob *srcData, - struct HksBlob *message, bool *isEd25519) + struct HksBlob *message, bool *needFree) { struct HksParam *algParam = NULL; int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam); @@ -322,7 +324,8 @@ static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const st return HKS_ERROR_CHECK_GET_ALG_FAIL; } - if (algParam->uint32Param != HKS_ALG_ED25519) { + if (algParam->uint32Param != HKS_ALG_ED25519 && algParam->uint32Param != HKS_ALG_RSA && + algParam->uint32Param != HKS_ALG_DSA && algParam->uint32Param != HKS_ALG_ECC) { struct HksParam *digestParam = NULL; ret = HksGetParam(paramSet, HKS_TAG_DIGEST, &digestParam); if (ret != HKS_SUCCESS) { @@ -344,11 +347,11 @@ static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const st return ret; } - *isEd25519 = false; + *needFree = true; } else { message->size = srcData->size; message->data = srcData->data; - *isEd25519 = true; + *needFree = false; } return HKS_SUCCESS; @@ -369,7 +372,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc return HKS_ERROR_BAD_STATE; } - bool isEd25519 = true; + bool needFree = true; struct HksBlob message = { 0, NULL }; do { ret = SignVerifyAuth(keyNode, paramSet); @@ -377,7 +380,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc break; } - ret = GetSignVerifyMessage(keyNode->paramSet, srcData, &message, &isEd25519); + ret = GetSignVerifyMessage(keyNode->paramSet, srcData, &message, &needFree); if (ret != HKS_SUCCESS) { HKS_LOG_E("SignVerify calc hash failed!"); break; @@ -402,7 +405,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc }while (0); HksFreeKeyNode(&keyNode); - if (!isEd25519) { + if (needFree) { HKS_FREE_PTR(message.data); } return ret; diff --git a/services/huks_standard/huks_service/main/core/BUILD.gn b/services/huks_standard/huks_service/main/core/BUILD.gn index 100e44d622ab4326daa1648c9c72dc9a8d9b715e..5bc51c74bcc1c970d61ac5d28dfcc5d741f48035 100644 --- a/services/huks_standard/huks_service/main/core/BUILD.gn +++ b/services/huks_standard/huks_service/main/core/BUILD.gn @@ -11,6 +11,7 @@ # See the License for the specific language governing permissions and # limitations under the License. +import("//base/security/huks/huks.gni") import("//build/ohos.gni") config("huks_config") { @@ -37,7 +38,14 @@ ohos_static_library("libhuks_service_core_standard_static") { "src/hks_double_list.c", "src/hks_operation.c", "src/hks_storage.c", + "src/hks_storage_file_lock.c", ] + if (non_rwlock_support) { + sources += [ "src/hks_lock_lite.c" ] + } else { + sources += [ "src/hks_lock.c" ] + } + deps = [ "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", "//third_party/openssl:libcrypto_static", diff --git a/services/huks_standard/huks_service/main/core/include/hks_file_operator.h b/services/huks_standard/huks_service/main/core/include/hks_file_operator.h index 54864681543af18dab6f0a7d80c40fe68148a3d8..b967b70d97542df0f0a08048c657b18e582418a9 100755 --- a/services/huks_standard/huks_service/main/core/include/hks_file_operator.h +++ b/services/huks_standard/huks_service/main/core/include/hks_file_operator.h @@ -84,6 +84,8 @@ bool HksOldVersionIsFileExist(const char *fileName); int32_t HksGetStoragePath(enum HksStoragePathType pathType, char *path, uint32_t *len); +int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen); + #ifdef __cplusplus } #endif diff --git a/services/huks_standard/huks_service/main/core/include/hks_lock.h b/services/huks_standard/huks_service/main/core/include/hks_lock.h new file mode 100755 index 0000000000000000000000000000000000000000..c79c1e1b81aef95abef849c983e9b944d5a41efe --- /dev/null +++ b/services/huks_standard/huks_service/main/core/include/hks_lock.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_LOCK_H +#define HKS_LOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct HksLock HksLock; + +HksLock *HksLockCreate(void); +int32_t HksLockLockRead(HksLock *lock); +int32_t HksLockUnlockRead(HksLock *lock); +int32_t HksLockLockWrite(HksLock *lock); +int32_t HksLockUnlockWrite(HksLock *lock); +void HksLockClose(HksLock *lock); + +#ifdef __cplusplus +} +#endif + +#endif // HKS_RW_LOCK_H diff --git a/services/huks_standard/huks_service/main/core/include/hks_mutex.h b/services/huks_standard/huks_service/main/core/include/hks_mutex.h new file mode 100755 index 0000000000000000000000000000000000000000..2362d4c35da0c0d51d0552a18d7ba266947d88ab --- /dev/null +++ b/services/huks_standard/huks_service/main/core/include/hks_mutex.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_MUTEX_H +#define HKS_MUTEX_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct HksMutex HksMutex; + +HksMutex *HksMutexCreate(void); +int32_t HksMutexLock(HksMutex *mutex); +int32_t HksMutexUnlock(HksMutex *mutex); +void HksMutexClose(HksMutex *mutex); + +#ifdef __cplusplus +} +#endif + +#endif // HKS_MUTEX_H \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/include/hks_rwlock.h b/services/huks_standard/huks_service/main/core/include/hks_rwlock.h new file mode 100755 index 0000000000000000000000000000000000000000..557b9b76e70419cb8370b27c1baede0e2a7e1f1e --- /dev/null +++ b/services/huks_standard/huks_service/main/core/include/hks_rwlock.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_RWLOCK_H +#define HKS_RWLOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct HksRwlock HksRwlock; + +HksRwlock *HksRwlockCreate(void); +int32_t HksRwlockLockRead(HksRwlock *lock); +int32_t HksRwlockUnlockRead(HksRwlock *lock); +int32_t HksRwlockLockWrite(HksRwlock *lock); +int32_t HksRwlockUnlockWrite(HksRwlock *lock); +void HksRwlockClose(HksRwlock *lock); + +#ifdef __cplusplus +} +#endif + +#endif // HKS_RWLOCK_H diff --git a/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h b/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h new file mode 100755 index 0000000000000000000000000000000000000000..d077116d7173d9df88094c74c2db3ab400c0b5bf --- /dev/null +++ b/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_STORAGE_FILE_LOCK_H +#define HKS_STORAGE_FILE_LOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct HksStorageFileLock HksStorageFileLock; + +HksStorageFileLock *HksStorageFileLockCreate(char *path); +int32_t HksStorageFileLockRead(HksStorageFileLock *lock); +int32_t HksStorageFileUnlockRead(HksStorageFileLock *lock); +int32_t HksStorageFileLockWrite(HksStorageFileLock *lock); +int32_t HksStorageFileUnlockWrite(HksStorageFileLock *lock); +void HksStorageFileLockRelease(HksStorageFileLock *lock); + +#ifdef __cplusplus +} +#endif + +#endif // HKS_STORAGE_FILE_LOCK_H \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_check.c b/services/huks_standard/huks_service/main/core/src/hks_client_check.c index 06adaf57adf4626f426bbde60178c08831863c1b..be6a910c3be69f6cbdc51b2827c944ff21ab3406 100644 --- a/services/huks_standard/huks_service/main/core/src/hks_client_check.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_check.c @@ -165,3 +165,18 @@ int32_t HksCheckGenerateRandomParams(const struct HksBlob *processName, const st return HKS_SUCCESS; } +#ifdef HKS_SUPPORT_API_ATTEST_KEY +int32_t HksCheckAttestKeyParams(const struct HksBlob *processName, const struct HksBlob *keyAlias, + const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HksCheckGenAndImportKeyParams(processName, keyAlias, paramSet, certChain); +} +#endif + +#ifdef HKS_SUPPORT_API_GET_CERTIFICATE_CHAIN +int32_t HksCheckGetCertificateChainParams(const struct HksBlob *processName, const struct HksBlob *keyAlias, + const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HksCheckGenAndImportKeyParams(processName, keyAlias, paramSet, certChain); +} +#endif \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service.c b/services/huks_standard/huks_service/main/core/src/hks_client_service.c index 4e4de694b681fa60f8efb3e3387067385abe630d..76e748044fb4b7aca138bee0273667dc2302efd1 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service.c @@ -421,10 +421,13 @@ static int32_t GetHksInnerKeyFormat(const struct HksParamSet *paramSet, const st case HKS_ALG_X25519: return TranslateToInnerCurve25519Format(algParam->uint32Param, key, outKey); #endif -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) case HKS_ALG_RSA: case HKS_ALG_ECC: case HKS_ALG_ECDH: + case HKS_ALG_DSA: + case HKS_ALG_DH: return TranslateFromX509PublicKey(key, outKey); #endif default: @@ -1220,13 +1223,67 @@ int32_t HksServiceSignWithDeviceKey(const struct HksBlob *processName, uint32_t int32_t HksServiceAttestKey(const struct HksBlob *processName, const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, struct HksBlob *certChain) { - return 0; +#ifdef HKS_SUPPORT_API_ATTEST_KEY + int32_t ret = HksCheckAttestKeyParams(processName, keyAlias, paramSet, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E(check attest key param fail); + return ret; + } + + struct HksParamSet *newParamSet = NULL; + struct HksBlob keyFromFile = { 0, NULL }; + ret = GetKeyAndNewParamSet(processName, keyAlias, paramSet, &keyFromFile, &newParamSet); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("GetKeyAndNewParamSet failed, ret = %d.", ret); + return ret; + } + + do { + ret = HksAccessAttestKey(&keyFromFile, newParamSet, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("HksAccessAttestKey fail, ret = %d.", ret); + break; + } + + ret = HksStoreKeyBlob(processName, keyAlias, HKS_STORAGE_TYPE_CERTCHAIN, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("store attest cert chain failed"); + } + } while (0); + + HKS_FREE_BLOB(keyFromFile); + HksFreeParamSet(&newParamSet) + return ret; +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif } int32_t HksServiceGetCertificateChain(const struct HksBlob *processName, const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, struct HksBlob *certChain) { - return 0; +#ifdef HKS_SUPPORT_API_GET_CERTIFICATE_CHAIN + int32_t ret = HksCheckGetCertificateChainParams(processName, keyAlias, paramSet, certChain); + if (ret != HKS_SUCCESS) { + return ret; + } + + struct HksBlob certFromFile = { 0, NULL }; + ret = GetKeyData(processName, keyAlias, &certFromFile, HKS_STORAGE_TYPE_CERTCHAIN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("HksGetKeyData fail, ret = %d.", ret); + return ret; + } + if (memcpy_s(certChain->data, certChain->size, certFromFile.data, certFromFile.size) != EOK) { + HKS_LOG_E("memcpy certChain fail."); + ret = HKS_ERROR_INSUFFICIENT_MEMORY; + } + certChain->size = certFromFile.size; + HKS_FREE_BLOB(certFromFile); + return ret; +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif } int32_t HksServiceWrapKey(const struct HksBlob *processName, const struct HksBlob *keyAlias, diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c index 55caad9994eb363629f176e15595262e944fe6af..e310c03a4d5299fb4f51e13c7ba465443aaacbeb 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c @@ -28,10 +28,12 @@ #include #include +#include "hks_crypto_hal.h" #include "hks_log.h" #include "hks_mem.h" -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) static int32_t EvpKeyToX509Format(EVP_PKEY *pkey, struct HksBlob *x509Key) { int32_t length = i2d_PUBKEY(pkey, NULL); @@ -59,7 +61,7 @@ static int32_t EvpKeyToX509Format(EVP_PKEY *pkey, struct HksBlob *x509Key) return HKS_SUCCESS; } -#ifdef HKS_SUPPORT_RSA_C +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY) static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlob *e, struct HksBlob *x509Key) { RSA *rsa = NULL; @@ -85,6 +87,8 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo HKS_LOG_E("RSA_set0_key error %s", ERR_reason_error_string(ERR_get_error())); break; } + rsaN = NULL; + rsaE = NULL; pkey = EVP_PKEY_new(); if (pkey == NULL) { HKS_LOG_E("pkey is null"); @@ -94,8 +98,6 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo HKS_LOG_E("EVP_PKEY_set1_RSA error %s", ERR_reason_error_string(ERR_get_error())); break; } - /* rsa need to be set to null to prevent Double-Free */ - rsa = NULL; result = EvpKeyToX509Format(pkey, x509Key); } while (0); @@ -107,13 +109,15 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo } #endif -#ifdef HKS_SUPPORT_ECC_C +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY) static int32_t GetEccNid(uint32_t keySize, int32_t *nid) { - int32_t nids[][2] = { /* 2 is size */ + int32_t nids[][2] = { + /* 2 is size */ + { 224, NID_secp224r1 }, { 256, NID_X9_62_prime256v1 }, { 384, NID_secp384r1 }, - { 521, NID_secp521r1 } + { 521, NID_secp521r1 }, }; uint32_t nidCount = sizeof(nids) / sizeof(nids[0]); @@ -129,8 +133,8 @@ static int32_t GetEccNid(uint32_t keySize, int32_t *nid) return HKS_ERROR_INVALID_ARGUMENT; } -static int32_t EccToX509PublicKey(uint32_t keySize, const struct HksBlob *x, const struct HksBlob *y, - struct HksBlob *x509Key) +static int32_t EccToX509PublicKey( + uint32_t keySize, const struct HksBlob *x, const struct HksBlob *y, struct HksBlob *x509Key) { int32_t nid; int32_t ret = GetEccNid(keySize, &nid); @@ -175,8 +179,6 @@ static int32_t EccToX509PublicKey(uint32_t keySize, const struct HksBlob *x, con break; } - /* ecKey need to be set to null to prevent Double-Free */ - ecKey = NULL; ret = EvpKeyToX509Format(pkey, x509Key); } while (0); @@ -187,6 +189,177 @@ static int32_t EccToX509PublicKey(uint32_t keySize, const struct HksBlob *x, con return ret; } #endif + +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GET_PUBLIC_KEY) +static int32_t GetDsaPubKeyParam( + const struct HksBlob *publicKey, struct HksBlob *y, struct HksBlob *p, struct HksBlob *q, struct HksBlob *g) +{ + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)publicKey->data; + uint32_t keyMaterialSize = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + keyMaterial->ySize + + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize; + if (publicKey->size < keyMaterialSize) { + HKS_LOG_E("translate to x509 public key invalid size"); + return HKS_ERROR_INVALID_ARGUMENT; + } + uint32_t offset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize; + y->size = keyMaterial->ySize; + y->data = publicKey->data + offset; + offset += keyMaterial->ySize; + p->size = keyMaterial->pSize; + p->data = publicKey->data + offset; + offset += keyMaterial->pSize; + q->size = keyMaterial->qSize; + q->data = publicKey->data + offset; + offset += keyMaterial->qSize; + g->size = keyMaterial->gSize; + g->data = publicKey->data + offset; + return HKS_SUCCESS; +} + +static int32_t DsaToX509PublicKey(const struct HksBlob *y, const struct HksBlob *p, const struct HksBlob *q, + const struct HksBlob *g, struct HksBlob *x509Key) +{ + int32_t ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + DSA *dsa = NULL; + BIGNUM *dsaY = BN_bin2bn(y->data, y->size, NULL); + BIGNUM *dsaP = BN_bin2bn(p->data, p->size, NULL); + BIGNUM *dsaQ = BN_bin2bn(q->data, q->size, NULL); + BIGNUM *dsaG = BN_bin2bn(g->data, g->size, NULL); + EVP_PKEY *pkey = NULL; + do { + dsa = DSA_new(); + if (dsa == NULL) { + HKS_LOG_E("DSA_new error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + + if (dsaY == NULL || dsaP == NULL || dsaQ == NULL || dsaG == NULL) { + HKS_LOG_E("DSA parameter is null."); + break; + } + + if (DSA_set0_key(dsa, dsaY, NULL) != 1) { + HKS_LOG_E("DSA_set0_key error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + dsaY = NULL; + if (DSA_set0_pqg(dsa, dsaP, dsaQ, dsaG) != 1) { + HKS_LOG_E("DSA_set0_pqg error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + dsaP = NULL; + dsaQ = NULL; + dsaG = NULL; + + pkey = EVP_PKEY_new(); + if (pkey == NULL) { + HKS_LOG_E("pkey is null"); + break; + } + + if (EVP_PKEY_set1_DSA(pkey, dsa) == 0) { + HKS_LOG_E("EVP_PKEY_set1_DSA error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + + ret = EvpKeyToX509Format(pkey, x509Key); + } while (0); + + SELF_FREE_PTR(dsa, DSA_free); + SELF_FREE_PTR(dsaY, BN_free); + SELF_FREE_PTR(dsaP, BN_free); + SELF_FREE_PTR(dsaQ, BN_free); + SELF_FREE_PTR(dsaG, BN_free); + SELF_FREE_PTR(pkey, EVP_PKEY_free); + return ret; +} + +static int32_t DsaPublicKeyToX509(const struct HksBlob *publicKey, struct HksBlob *x509Key) +{ + struct HksBlob y; + struct HksBlob p; + struct HksBlob q; + struct HksBlob g; + int32_t ret = GetDsaPubKeyParam(publicKey, &y, &p, &q, &g); + if (ret != HKS_SUCCESS) { + return ret; + } + + return DsaToX509PublicKey(&y, &p, &q, &g, x509Key); +} + +#endif + +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) +static int32_t GetDhNid(uint32_t keySize, int32_t *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return HKS_SUCCESS; + default: + return HKS_ERROR_INVALID_ARGUMENT; + } +} + +static int32_t DhToX509PublicKey( + uint32_t keySize, const struct HksBlob *pubKey, const struct HksBlob *privKey, struct HksBlob *x509Key) +{ + int32_t nid; + int32_t ret = GetDhNid(keySize, &nid); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("GetNidFromKeySize fail"); + return ret; + } + + BIGNUM *pub = NULL; + DH *dh = NULL; + EVP_PKEY *pkey = NULL; + do { + dh = DH_new_by_nid(nid); + if (dh == NULL) { + HKS_LOG_E("DH_new_by_nid error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + + pub = BN_bin2bn(pubKey->data, pubKey->size, NULL); + if (pub == NULL) { + HKS_LOG_E("BN_bin2bn error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + + if (DH_set0_key(dh, pub, NULL) != 1) { + HKS_LOG_E("DH_set0_key error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + pub = NULL; + + pkey = EVP_PKEY_new(); + if (pkey == NULL) { + HKS_LOG_E("pkey is null"); + break; + } + + if (EVP_PKEY_set1_DH(pkey, dh) == 0) { + HKS_LOG_E("EVP_PKEY_set1_DH error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + + ret = EvpKeyToX509Format(pkey, x509Key); + } while (0); + + SELF_FREE_PTR(dh, DH_free); + SELF_FREE_PTR(pub, BN_free); + SELF_FREE_PTR(pkey, EVP_PKEY_free); + return ret; +} +#endif #endif #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C) @@ -242,18 +415,26 @@ int32_t TranslateToX509PublicKey(const struct HksBlob *publicKey, struct HksBlob struct HksBlob material2 = { publicKeyInfo->eOrYSize, publicKey->data + offset }; switch (publicKeyInfo->keyAlg) { -#ifdef HKS_SUPPORT_RSA_C +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY) case HKS_ALG_RSA: return RsaToX509PublicKey(&material1, &material2, x509Key); #endif -#ifdef HKS_SUPPORT_ECC_C +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY) case HKS_ALG_ECC: return EccToX509PublicKey(publicKeyInfo->keySize, &material1, &material2, x509Key); #endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GET_PUBLIC_KEY) + case HKS_ALG_DSA: + return DsaPublicKeyToX509(publicKey, x509Key); +#endif #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C) case HKS_ALG_X25519: case HKS_ALG_ED25519: return Curve25519ToX509PublicKey(&material1, x509Key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return DhToX509PublicKey(publicKeyInfo->keySize, &material1, NULL, x509Key); #endif default: HKS_LOG_E("Unsupport alg type! type = 0x%X", publicKeyInfo->keyAlg); @@ -261,11 +442,12 @@ int32_t TranslateToX509PublicKey(const struct HksBlob *publicKey, struct HksBlob } } -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #ifdef HKS_SUPPORT_RSA_C static int32_t X509PublicKeyToRsa(EVP_PKEY *pkey, struct HksBlob *rsaPublicKey) { - RSA *rsa = EVP_PKEY_get1_RSA(pkey); + RSA *rsa = EVP_PKEY_get0_RSA(pkey); if (rsa == NULL) { HKS_LOG_E("EVP_PKEY_get1_RSA error %s", ERR_reason_error_string(ERR_get_error())); return HKS_ERROR_NULL_POINTER; @@ -279,7 +461,7 @@ static int32_t X509PublicKeyToRsa(EVP_PKEY *pkey, struct HksBlob *rsaPublicKey) } /* n and e in RSA algorithm is small, will never overflow. */ - uint32_t totalSize = nSize + eSize + sizeof(struct HksPubKeyInfo); + uint32_t totalSize = nSize + eSize + sizeof(struct HksPubKeyInfo); uint8_t *keyBuffer = HksMalloc(totalSize); if (keyBuffer == NULL) { HKS_LOG_E("X509PublicKeyToRsa keyBuffer failed"); @@ -288,9 +470,10 @@ static int32_t X509PublicKeyToRsa(EVP_PKEY *pkey, struct HksBlob *rsaPublicKey) struct HksPubKeyInfo *pubKeyInfo = (struct HksPubKeyInfo *)keyBuffer; pubKeyInfo->keyAlg = HKS_ALG_RSA; - pubKeyInfo->keySize = RSA_size(rsa); + pubKeyInfo->keySize = RSA_size(rsa) * HKS_BITS_PER_BYTE; pubKeyInfo->nOrXSize = nSize; pubKeyInfo->eOrYSize = eSize; + pubKeyInfo->placeHolder = 0; if (BN_bn2bin(RSA_get0_n(rsa), keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || BN_bn2bin(RSA_get0_e(rsa), keyBuffer + sizeof(struct HksPubKeyInfo) + nSize) == 0) { HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); @@ -317,8 +500,8 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) break; } - if (EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ecKey), - EC_KEY_get0_public_key(ecKey), x, y, NULL) == 0) { + if (EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ecKey), EC_KEY_get0_public_key(ecKey), x, y, NULL) == + 0) { HKS_LOG_E("EC_POINT_get_affine_coordinates_GFp error %s", ERR_reason_error_string(ERR_get_error())); break; } @@ -343,6 +526,7 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) pubKeyInfo->keySize = EC_GROUP_order_bits(EC_KEY_get0_group(ecKey)); pubKeyInfo->nOrXSize = xSize; pubKeyInfo->eOrYSize = ySize; + pubKeyInfo->placeHolder = 0; if (BN_bn2bin(x, keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || BN_bn2bin(y, keyBuffer + sizeof(struct HksPubKeyInfo) + xSize) == 0) { HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); @@ -362,7 +546,7 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) static int32_t X509PublicKeyToEcc(EVP_PKEY *pkey, struct HksBlob *eccPublicKey) { - EC_KEY *ecKey = EVP_PKEY_get1_EC_KEY(pkey); + EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey); if (ecKey == NULL) { HKS_LOG_E("EVP_PKEY_get1_EC_KEY error %s", ERR_reason_error_string(ERR_get_error())); return HKS_ERROR_NULL_POINTER; @@ -372,6 +556,84 @@ static int32_t X509PublicKeyToEcc(EVP_PKEY *pkey, struct HksBlob *eccPublicKey) } #endif +#ifdef HKS_SUPPORT_DSA_C +static int32_t X509PublicKeyToDsa(EVP_PKEY *pkey, struct HksBlob *dsaPublicKey) +{ + DSA *dsa = EVP_PKEY_get0_DSA(pkey); + if (dsa == NULL) { + HKS_LOG_E("EVP_PKEY_get1_DSA error %s", ERR_reason_error_string(ERR_get_error())); + return HKS_ERROR_NULL_POINTER; + } + + const BIGNUM *y = DSA_get0_pub_key(dsa); + const BIGNUM *p = DSA_get0_p(dsa); + const BIGNUM *q = DSA_get0_q(dsa); + const BIGNUM *g = DSA_get0_g(dsa); + uint32_t ySize = BN_num_bytes(y); + uint32_t pSize = BN_num_bytes(p); + uint32_t qSize = BN_num_bytes(q); + uint32_t gSize = BN_num_bytes(g); + + uint32_t totalSize = sizeof(struct KeyMaterialDsa) + ySize + pSize + qSize + gSize; + uint8_t *keyBuffer = HksMalloc(totalSize); + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)keyBuffer; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = (ySize + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE; + keyMaterial->xSize = 0; + keyMaterial->ySize = ySize; + keyMaterial->pSize = pSize; + keyMaterial->qSize = qSize; + keyMaterial->gSize = gSize; + + if ((BN_bn2bin(y, keyBuffer + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize) == 0) || + (BN_bn2bin(p, keyBuffer + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize) == 0) || + (BN_bn2bin(q, keyBuffer + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize) == 0) || + (BN_bn2bin(g, keyBuffer + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize + qSize) == 0)) { + HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); + HKS_FREE_PTR(keyBuffer); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + dsaPublicKey->size = totalSize; + dsaPublicKey->data = keyBuffer; + + return HKS_SUCCESS; +} +#endif + +#ifdef HKS_SUPPORT_DH_C +static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey) +{ + DH *dh = EVP_PKEY_get0_DH(pkey); + if (dh == NULL) { + HKS_LOG_E("EVP_PKEY_get0_DH error %s", ERR_reason_error_string(ERR_get_error())); + return HKS_ERROR_NULL_POINTER; + } + + const BIGNUM *pubKey = DH_get0_pub_key(dh); + uint32_t pubKeySize = BN_num_bytes(pubKey); + + uint32_t totalSize = sizeof(struct KeyMaterialDh) + pubKeySize; + uint8_t *keyBuffer = HksMalloc(totalSize); + if (keyBuffer == NULL) { + HKS_LOG_E("alloc keyBuffer failed"); + return HKS_ERROR_MALLOC_FAIL; + } + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = DH_bits(dh); + keyMaterial->pubKeySize = pubKeySize; + keyMaterial->priKeySize = 0; + keyMaterial->reserved = 0; + + BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); + + dhPublicKey->size = totalSize; + dhPublicKey->data = keyBuffer; + + return HKS_SUCCESS; +} +#endif + int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob *publicKey) { if (x509Key == NULL || x509Key->data == NULL || x509Key->size == 0 || publicKey == NULL) { @@ -379,7 +641,9 @@ int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob return HKS_ERROR_INVALID_ARGUMENT; } - EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size); + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); if (pkey == NULL) { return HKS_ERROR_INVALID_ARGUMENT; } @@ -397,6 +661,18 @@ int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob ret = X509PublicKeyToEcc(pkey, publicKey); #else ret = HKS_ERROR_INVALID_ALGORITHM; +#endif + } else if (keyType == EVP_PKEY_DSA) { +#ifdef HKS_SUPPORT_DSA_C + ret = X509PublicKeyToDsa(pkey, publicKey); +#else + ret = HKS_ERROR_INVALID_ALGORITHM; +#endif + } else if (keyType == EVP_PKEY_DH) { +#ifdef HKS_SUPPORT_DH_C + ret = X509PublicKeyToDh(pkey, publicKey); +#else + ret = HKS_ERROR_INVALID_ALGORITHM; #endif } else { HKS_LOG_E("Unsupport alg type!"); @@ -444,7 +720,8 @@ int32_t TranslateToInnerCurve25519Format(const uint32_t alg, const struct HksBlo #ifdef HKS_SUPPORT_AES_C int32_t TranslateToInnerAesFormat(const struct HksBlob *key, struct HksBlob *outKey) { - if ((key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)) && (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256))) { + if ((key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)) && (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192)) && + (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256))) { HKS_LOG_E("Invalid aes key size! key size = 0x%X", key->size); return HKS_ERROR_INVALID_KEY_INFO; } diff --git a/services/huks_standard/huks_service/main/core/src/hks_lock.c b/services/huks_standard/huks_service/main/core/src/hks_lock.c new file mode 100755 index 0000000000000000000000000000000000000000..2b2063faedb9e962a0b79e41dbdc9d7663518e26 --- /dev/null +++ b/services/huks_standard/huks_service/main/core/src/hks_lock.c @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2021 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 "hks_lock.h" + +#include "hks_mem.h" +#include "hks_rwlock.h" + +struct HksLock { + HksRwlock *lock; +}; + +HksLock *HksLockCreate(void) +{ + HksLock *lock = HksMalloc(sizeof(HksLock)); + if (lock != NULL) { + lock->lock = HksRwlockCreate(); + if (lock->lock == NULL) { + HksFree(lock); + lock = NULL; + } + } + return lock; +} + +int32_t HksLockLockRead(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksRwlockLockRead(lock->lock); +} + +int32_t HksLockUnlockRead(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksRwlockUnlockRead(lock->lock); +} + +int32_t HksLockLockWrite(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksRwlockLockWrite(lock->lock); +} + +int32_t HksLockUnlockWrite(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksRwlockUnlockWrite(lock->lock); +} + +void HksLockClose(HksLock *lock) +{ + if (lock == NULL) { + return; + } + HksRwlockClose(lock->lock); + HksFree(lock); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/src/hks_lock_lite.c b/services/huks_standard/huks_service/main/core/src/hks_lock_lite.c new file mode 100755 index 0000000000000000000000000000000000000000..e74dc6c02559b4b52fd70263a07f455783ba7634 --- /dev/null +++ b/services/huks_standard/huks_service/main/core/src/hks_lock_lite.c @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2021 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 "hks_lock.h" + +#include "hks_mem.h" +#include "hks_mutex.h" + +struct HksLock { + HksMutex *lock; +}; + +HksLock *HksLockCreate(void) +{ + HksLock *lock = HksMalloc(sizeof(HksLock)); + if (lock != NULL) { + lock->lock = HksMutexCreate(); + if (lock->lock == NULL) { + HksFree(lock); + lock = NULL; + } + } + return lock; +} + +int32_t HksLockLockRead(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksMutexLock(lock->lock); +} + +int32_t HksLockUnlockRead(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksMutexUnlock(lock->lock); +} + +int32_t HksLockLockWrite(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksMutexLock(lock->lock); +} + +int32_t HksLockUnlockWrite(HksLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksMutexUnlock(lock->lock); +} + +void HksLockClose(HksLock *lock) +{ + if (lock == NULL) { + return; + } + HksMutexClose(lock->lock); + HksFree(lock); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/src/hks_storage.c b/services/huks_standard/huks_service/main/core/src/hks_storage.c index 86548dddb11c4369bcb7aa5ef693e9f342176e2b..20b719fea0e0991f7780c48bbf10cc78c453ff6b 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_storage.c +++ b/services/huks_standard/huks_service/main/core/src/hks_storage.c @@ -26,6 +26,7 @@ #include "hks_file_operator.h" #include "hks_log.h" #include "hks_mem.h" +#include "hks_storage_file_lock.h" #define HKS_ENCODE_OFFSET_LEN 6 #define HKS_ENCODE_KEY_SALT_VALUE 0x3f @@ -282,6 +283,71 @@ static int32_t MakeDirIfNotExist(const char *path) return HKS_SUCCESS; } +static int32_t HksStorageWriteFile( + const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return ret; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockWrite(lock); + ret = HksFileWrite(path, fileName, offset, buf, len); + HksStorageFileUnlockWrite(lock); + HksStorageFileLockRelease(lock); + return ret; +#else + return HksFileWrite(path, fileName, offset, buf, len); +#endif +} + +static uint32_t HksStorageReadFile( + const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return 0; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockRead(lock); + uint32_t size = HksFileRead(path, fileName, offset, buf, len); + HksStorageFileUnlockRead(lock); + HksStorageFileLockRelease(lock); +#else + uint32_t size = HksFileRead(path, fileName, offset, buf, len); +#endif + return size; +} + +static int32_t HksStorageRemoveFile(const char *path, const char *fileName) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return ret; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockWrite(lock); + ret = HksFileRemove(path, fileName); + HksStorageFileUnlockWrite(lock); + HksStorageFileLockRelease(lock); +#else + int32_t ret = HksFileRemove(path, fileName); +#endif + return ret; +} + #ifdef SUPPORT_STORAGE_BACKUP static int32_t GetBakFullPath(const char *path, const char *processName, const char *storeName, struct HksStoreFileInfo *fileInfo) @@ -328,7 +394,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName, int32_t ret; do { - size = HksFileRead(srcPath, srcFileName, 0, buffer, size); + size = HksStorageReadFile(srcPath, srcFileName, 0, buffer, size); if (size == 0) { HKS_LOG_E("read file failed, ret = %u.", size); ret = HKS_ERROR_READ_FILE_FAIL; @@ -341,7 +407,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName, break; } - ret = HksFileWrite(destPath, destFileName, 0, buffer, size); + ret = HksStorageWriteFile(destPath, destFileName, 0, buffer, size); if (ret != HKS_SUCCESS) { HKS_LOG_E("file write destPath failed, ret = %d.", ret); break; @@ -393,7 +459,7 @@ static int32_t GetKeyBlobFromFile(const char *path, const char *fileName, struct return HKS_ERROR_INSUFFICIENT_DATA; } - size = HksFileRead(path, fileName, 0, keyBlob->data, keyBlob->size); + size = HksStorageReadFile(path, fileName, 0, keyBlob->data, keyBlob->size); if (size == 0) { HKS_LOG_E("file read failed, ret = %u.", size); return HKS_ERROR_READ_FILE_FAIL; @@ -418,7 +484,7 @@ static int32_t SaveKeyBlob(const char *processPath, const char *path, const char return ret; } - return HksFileWrite(path, fileName, 0, keyBlob->data, keyBlob->size); + return HksStorageWriteFile(path, fileName, 0, keyBlob->data, keyBlob->size); } static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) @@ -429,7 +495,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) return HKS_ERROR_NOT_EXIST; } - int32_t ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName); + int32_t ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove file failed, ret = %d.", ret); return ret; @@ -442,7 +508,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) int32_t ret = HKS_SUCCESS; if (isMainFileExist == HKS_SUCCESS) { - ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName); + ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove file failed, ret = %d.", ret); return ret; @@ -450,7 +516,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) } if (isBakFileExist == HKS_SUCCESS) { - ret = HksFileRemove(fileInfo->bakPath.path, fileInfo->bakPath.fileName); + ret = HksStorageRemoveFile(fileInfo->bakPath.path, fileInfo->bakPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove bakfile failed, ret = %d.", ret); return ret; diff --git a/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c b/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c new file mode 100755 index 0000000000000000000000000000000000000000..565d1bbb2df6f2327c1e317e7008dd08a5b55550 --- /dev/null +++ b/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2021 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 "hks_storage_file_lock.h" + +#include +#include +#include + +#include "securec.h" + +#include "hks_lock.h" +#include "hks_mem.h" +#include "hks_mutex.h" + +struct HksStorageFileLock { + char *path; + HksLock *lock; + uint32_t ref; + HksStorageFileLock *next; +}; + +static HksStorageFileLock *g_lockListFirst = NULL; +static HksStorageFileLock *g_lockListLast = NULL; +static HksMutex *g_lockListLock = NULL; + +static void FreeFileLock(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return; + } + + if (lock->path) { + HksFree(lock->path); + lock->path = NULL; + } + + if (lock->lock) { + HksLockClose(lock->lock); + lock->lock = NULL; + } + + HksFree(lock); +} + +static void ClearLockList(void) +{ + if (g_lockListFirst == NULL) { + return; + } + + HksStorageFileLock *iter = g_lockListFirst; + HksStorageFileLock *temp = NULL; + while (iter != NULL) { + temp = iter->next; + FreeFileLock(iter); + iter = temp; + } + + g_lockListFirst = NULL; + g_lockListLast = NULL; +} + +static HksStorageFileLock *FindFileLock(char *path) +{ + HksStorageFileLock *iter = g_lockListFirst; + while (iter != NULL) { + if (strcmp(path, iter->path) == 0) { + return iter; + } else { + iter = iter->next; + } + } + return NULL; +} + +static HksStorageFileLock *AllocFileLock(char *path) +{ + HksStorageFileLock *lock = HksMalloc(sizeof(HksStorageFileLock)); + if (lock != NULL) { + size_t len = strlen(path); + lock->path = HksMalloc(len + 1); + if (lock->path != NULL) { + (void)strcpy_s(lock->path, len + 1, path); + } + lock->lock = HksLockCreate(); + lock->ref = 1; + lock->next = NULL; + + if (lock->path == NULL || lock->lock == NULL) { + FreeFileLock(lock); + lock = NULL; + } + } + return lock; +} + +static void AddRef(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return; + } + + lock->ref++; +} + +static void AppendFileLock(HksStorageFileLock *lock) +{ + if (g_lockListFirst == NULL) { + g_lockListFirst = lock; + g_lockListFirst->next = NULL; + g_lockListLast = lock; + return; + } + + if (g_lockListLast != NULL) { + g_lockListLast->next = lock; + g_lockListLast = lock; + g_lockListLast->next = NULL; + } +} + +HksStorageFileLock *HksStorageFileLockCreate(char *path) +{ + if (path == NULL) { + return NULL; + } + + if (g_lockListLock == NULL) { + return NULL; + } + + if (HksMutexLock(g_lockListLock) != 0) { + return NULL; + } + HksStorageFileLock *lock = FindFileLock(path); + if (lock == NULL) { + lock = AllocFileLock(path); + if (lock != NULL) { + AppendFileLock(lock); + } + } else { + AddRef(lock); + } + (void)HksMutexUnlock(g_lockListLock); + + return lock; +} + +int32_t HksStorageFileLockRead(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksLockLockRead(lock->lock); +} + +int32_t HksStorageFileUnlockRead(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksLockUnlockRead(lock->lock); +} + +int32_t HksStorageFileLockWrite(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksLockLockWrite(lock->lock); +} + +int32_t HksStorageFileUnlockWrite(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return -1; + } + return HksLockUnlockWrite(lock->lock); +} + +static bool IsLockInList(HksStorageFileLock *lock) +{ + HksStorageFileLock *iter = g_lockListFirst; + while (iter != NULL) { + if (lock == iter) { + return true; + } else { + iter = iter->next; + } + } + return false; +} + +static uint32_t Release(HksStorageFileLock *lock) +{ + uint32_t ref = 0; + HksStorageFileLock *iter = g_lockListFirst; + HksStorageFileLock *previous = NULL; + bool remove = false; + while (iter != NULL) { + if (lock == iter) { + lock->ref--; + ref = lock->ref; + if (ref == 0) { + remove = true; + } + break; + } else { + previous = iter; + iter = iter->next; + } + } + + if (remove) { + if (previous != NULL) { + previous->next = iter->next; + } else { + g_lockListFirst = iter->next; + } + if (g_lockListLast == lock) { + g_lockListLast = previous; + } + FreeFileLock(lock); + } + + return ref; +} + +void HksStorageFileLockRelease(HksStorageFileLock *lock) +{ + if (lock == NULL) { + return; + } + + if (g_lockListLock == NULL) { + return; + } + + if (HksMutexLock(g_lockListLock) != 0) { + return; + } + + if (IsLockInList(lock)) { + Release(lock); + } + + (void)HksMutexUnlock(g_lockListLock); +} + +__attribute__((constructor)) static void OnLoad(void) +{ + g_lockListLock = HksMutexCreate(); + g_lockListFirst = NULL; + g_lockListLast = NULL; +} + +__attribute__((destructor)) static void OnUnload(void) +{ + if (g_lockListLock != NULL) { + HksMutexClose(g_lockListLock); + g_lockListLock = NULL; + } + + ClearLockList(); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/BUILD.gn b/services/huks_standard/huks_service/main/os_dependency/BUILD.gn index a7867304a50fbc1cd35a7bf3b4f3f778fdaa9f7c..0059998836ab0b4d467d770ecb4ef76d08a7253a 100644 --- a/services/huks_standard/huks_service/main/os_dependency/BUILD.gn +++ b/services/huks_standard/huks_service/main/os_dependency/BUILD.gn @@ -32,6 +32,8 @@ ohos_static_library("libhuks_service_os_dependency_standard_static") { ] sources = [ "posix/hks_file_operator.c", + "posix/hks_mutex.c", + "posix/hks_rwlock.c", "sa/hks_sa.cpp", ] deps = [ @@ -44,7 +46,7 @@ ohos_static_library("libhuks_service_os_dependency_standard_static") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] complete_static_lib = true diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c new file mode 100755 index 0000000000000000000000000000000000000000..dbcf2523b1b5150c02a2cc4bf76d4ab51357cda9 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_access.h" +#include "hks_teec.h" + +int32_t HksAccessInitialize(void) +{ + return HKS_ERROR_NOT_SUPPORTED; +} + +int32_t HksAccessRefresh(void) +{ + return HKS_ERROR_NOT_SUPPORTED; +} + +int32_t HksAccessGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, + const struct HksBlob *keyIn, struct HksBlob *keyOut) +{ + (void)keyIn; + return HksTeeGenerateKey(keyBlob, paramSetIn, keyOut); +} + +int32_t HksAccessSign(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature) +{ + return HksTeeSign(key, paramSet, srcData, signature); +} + +int32_t HksAccessVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ + return HksTeeVerify(key, paramSet, srcData, signature); +} + +int32_t HksAccessEncrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText) +{ + return HksTeeEncrypt(key, paramSet, plainText, cipherText); +} + +int32_t HksAccessDecrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText) +{ + return HksTeeDecrypt(key, paramSet, cipherText, plainText); +} + +int32_t HksAccessGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) +{ + return HksTeeGenerateRandom(paramSet, random); +} + +int32_t HksAccessImportKey(const struct HksBlob *keyAlias, const struct HksBlob *key, + const struct HksParamSet *paramSet, struct HksBlob *keyOut) +{ + (void)keyAlias; + return HksTeeImportKey(key, paramSet, keyOut); +} + +int32_t HksAccessExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *keyOut) +{ + return HksTeeExportPublicKey(key, paramSet, keyOut); +} + +int32_t HksAccessAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey) +{ + return HksTeeAgreeKey(paramSet, privateKey, peerPublicKey, agreedKey); +} + +int32_t HksAccessDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, + struct HksBlob *derivedKey) +{ + return HksTeeDeriveKey(paramSet, kdfKey, derivedKey); +} + +int32_t HksAccessMac(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac) +{ + return HksTeeMac(key, paramSet, srcData, mac); +} + +int32_t HksAccessCheckKeyValidity(const struct HksParamSet *paramSet, const struct HksBlob *key) +{ + return HksTeeCheckKeyLegality(paramSet, key); +} + +int32_t HksAccessExportTrustCerts(struct HksBlob *certChain) +{ + return HksTeeExportTrustCerts(certChain); +} + +int32_t HksAccessImportTrustCerts(const struct HksBlob *certChain) +{ + return HksTeeImportTrustCerts(certChain); +} + +int32_t HcmAccessIsDeviceKeyExist(const struct HksParamSet *paramSet) +{ + (void)paramSet; + return HcmTeeIsDeviceKeyExist(); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c new file mode 100755 index 0000000000000000000000000000000000000000..70c7a185a9eb4cf135c08726f1ed0b456dd18d23 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c @@ -0,0 +1,706 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_teec.h" + +#include + +#include "hks_access.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "tee_client_api.h" +#include "tee_client_id.h" +#include "tee_client_type.h" + +#ifdef HKS_ROUTER +#define HISI_HKS_TA_PATH "/lib/sec/86310d18-5659-47c9-b212-841a3ca4f814.sec" +#else +#define HISI_HKS_TA_PATH "/vendor/bin/86310d18-5659-47c9-b212-841a3ca4f814.sec" +#endif + +#define MAX_TEE_PARAMS_NUMS 4 +#define PROVISION_PARAM_COUNT 4 + +#define TEE_SERVICE_HKS_TA \ +{ \ + 0x86310d18, \ + 0x5659, \ + 0x47c9, \ + { \ + 0xb2, 0x12, 0x84, 0x1a, 0x3c, 0xa4, 0xf8, 0x14 \ + } \ +} + +typedef struct { + enum TEEC_ParamType paramType; + uint32_t index; + union { + TEEC_TempMemoryReference tmpRef; + TEEC_Value value; + }; +} TeecOpParam; + +typedef struct { + TeecOpParam *params; + uint32_t length; +} TeecOpParamSet; + +typedef struct { + uint32_t paramTypes; + TeecOpParamSet paramSet; +} TeecOperation; + +static TEEC_Context *g_context = NULL; +static TEEC_Session *g_sessionSelfStart = NULL; + +static inline void InitializeBlob(struct HksBlob *blob, uint32_t size, uint8_t *data) +{ + if (blob != NULL) { + blob->data = data; + blob->size = size; + } +} + +static inline uint64_t Uint32To64(uint32_t high, uint32_t low) +{ + return ((uint64_t)(high) << 32) + (uint64_t)(low); /* 32 is higher bits */ +} + +static TEEC_Result TeecUuidInit(TEEC_Context *context, const char *taPath, + TEEC_UUID *uuid, const char *taName, uint32_t srcLen) +{ + if (!access(taPath, F_OK)) { + context->ta_path = (uint8_t *)taPath; + if (memcpy_s(uuid, sizeof(TEEC_UUID), taName, srcLen) != EOK) { + HKS_LOG_E("memcpy failed while copy ta name"); + return TEEC_ERROR_GENERIC; + } + + HKS_LOG_I("run on ta path:%s ", taPath); + return TEEC_SUCCESS; + } + + return TEEC_ERROR_GENERIC; +} + +static TEEC_Result OpenSession(TEEC_Context *context, TEEC_Session **session) +{ + TEEC_UUID uuid = { 0, 0, 0, { 0 } }; + TEEC_UUID uuidHisi = TEE_SERVICE_HKS_TA; + TEEC_Result ret = TeecUuidInit(context, HISI_HKS_TA_PATH, &uuid, (const char*)&uuidHisi, sizeof(TEEC_UUID)); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("ta uuid init failed!"); + return TEEC_ERROR_GENERIC; + } + + TEEC_Session *localSession = (TEEC_Session *)HksMalloc(sizeof(TEEC_Session)); + if (localSession == NULL) { + HKS_LOG_E("out of memory!"); + return (TEEC_Result)TEEC_ERROR_OUT_OF_MEMORY; + } + + TEEC_Operation operation; + + (void)memset_s(&operation, sizeof(operation), 0, sizeof(operation)); + operation.started = 1; + operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_NONE, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT); + + uint32_t origin = 0; + ret = TEEC_OpenSession(context, localSession, &uuid, TEEC_LOGIN_IDENTIFY, NULL, &operation, &origin); + if (ret != TEEC_SUCCESS) { + HksFree(localSession); + HKS_LOG_E("open ta session failed, ret=0x%x, origin=%u", ret, origin); + return ret; + } + + *session = localSession; + HKS_LOG_I("Open Session success"); + return ret; +} + +static TEEC_Result TeecOpen(void) +{ + if (g_context != NULL) { + return TEEC_SUCCESS; + } + + g_context = HksMalloc(sizeof(TEEC_Context)); + if (g_context == NULL) { + HKS_LOG_E("memory allocate failed!"); + return TEEC_ERROR_OUT_OF_MEMORY; + } + + TEEC_Result result = TEEC_InitializeContext(NULL, g_context); + if (result != TEEC_SUCCESS) { + HKS_LOG_E("Initialize TEE context failed, ret=0x%x", result); + HKS_FREE_PTR(g_context); + return result; + } + + result = OpenSession(g_context, &g_sessionSelfStart); + if (result != TEEC_SUCCESS) { + TEEC_FinalizeContext(g_context); + HKS_FREE_PTR(g_context); + HKS_LOG_E("Open Session failed!"); + } + + return result; +} + +static void FillUpCommand(const TeecOpParam *src, TEEC_Parameter *des) +{ + switch (src->paramType) { + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_OUTPUT: + case TEEC_MEMREF_TEMP_INOUT: + des->tmpref.buffer = src->tmpRef.buffer; + des->tmpref.size = src->tmpRef.size; + break; + case TEEC_VALUE_INPUT: + case TEEC_VALUE_OUTPUT: + case TEEC_VALUE_INOUT: + des->value.a = src->value.a; + des->value.b = src->value.b; + break; + case TEEC_NONE: + break; + default: + break; + } +} + +static TEEC_Result TeecRequestCmdInner(enum HksCmdId pkiCmdId, TEEC_Operation *operation, + TeecOperation *teecOperation) +{ + TEEC_Result ret; + if (g_sessionSelfStart == NULL) { + ret = TeecOpen(); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("teec open failed!"); + return ret; + } + } + + if (memset_s(operation, sizeof(TEEC_Operation), 0, sizeof(TEEC_Operation)) != EOK) { + HKS_LOG_E("memset for operation failed!"); + return TEEC_ERROR_GENERIC; + } + + operation->started = 1; + operation->paramTypes = teecOperation->paramTypes; + + TeecOpParamSet paramSet = teecOperation->paramSet; + TeecOpParam *params = paramSet.params; + for (uint32_t i = 0; i < paramSet.length; i++) { + FillUpCommand(¶ms[i], &operation->params[params[i].index]); + } + + uint32_t retOrigin = 0; + ret = TEEC_InvokeCommand(g_sessionSelfStart, pkiCmdId, operation, &retOrigin); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("invoke km command failed, cmd = %u, ret = 0x%x, retOrigin = %u", pkiCmdId, ret, retOrigin); + } + + return ret; +} + +static void FillUpArgs(const struct HksParam *src, TeecOpParam *dest) +{ + switch (dest->paramType) { + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_OUTPUT: + case TEEC_MEMREF_TEMP_INOUT: + dest->tmpRef.buffer = src->blob.data; + dest->tmpRef.size = src->blob.size; + break; + case TEEC_VALUE_INPUT: + case TEEC_VALUE_OUTPUT: + case TEEC_VALUE_INOUT: + dest->value.a = (uint32_t)((src->uint64Param) >> 32); /* 32 is higher bits */ + dest->value.b = (uint32_t)(src->uint64Param); + break; + case TEEC_NONE: + break; + default: + break; + } +} + +static int32_t HksTeeCommand(uint32_t paramTypes, const struct HksParam params[MAX_TEE_PARAMS_NUMS], + uint32_t msgType, TEEC_Operation *operation) +{ + TeecOpParam opParams[MAX_TEE_PARAMS_NUMS]; + for (uint32_t i = 0; i < MAX_TEE_PARAMS_NUMS; ++i) { + opParams[i].index = i; + opParams[i].paramType = TEEC_PARAM_TYPE_GET(paramTypes, i); + FillUpArgs(¶ms[i], &opParams[i]); + } + + TeecOpParamSet teeParams = { + .params = opParams, + .length = MAX_TEE_PARAMS_NUMS + }; + TeecOperation teecOperation = { + .paramTypes = paramTypes, + .paramSet = teeParams + }; + + return TeecRequestCmdInner(msgType, operation, &teecOperation); +} + +int32_t HksTeeOpen(void) +{ + return TeecOpen(); +} + +#ifdef HKS_SUPPORT_API_INJECT_KEY +int32_t HksTeeProvision(const struct HksBlob *keybox, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature, struct HksBlob *certData) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_MEMREF_TEMP_INOUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keybox->size, keybox->data); + InitializeBlob(¶ms[1].blob, challenge->size, challenge->data); + InitializeBlob(¶ms[2].blob, signature->size, signature->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, certData->size, certData->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_INJECT_KEY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command key provision failed"); + return ret; + } + + ret = ProvisionVerify(&operation, challengeIn, (PROVISION_PARAM_COUNT >> 1), NULL, false); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeVerifyKeybox failed\n"); + } + + return ret; +} +#endif + +#ifdef HKS_SUPPORT_API_INJECT_KEY_VERIFY +int32_t HksTeeProvisionVerify(const struct HksBlob *verify, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_INOUT, + TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, signature->size, signature->data); + InitializeBlob(¶ms[1].blob, challenge->size, challenge->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_INJECT_KEY_VERIFY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command key provision verify failed"); + return ret; + } + + /* here we only have one key signature to verify, so the count is half of the provision param count */ + ret = ProvisionVerify(&operation, challengeIn, (PROVISION_PARAM_COUNT >> 1), verify, true); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("verify provision failed"); + } + + return ret; +} +#endif + +int32_t HksTeeGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, struct HksBlob *keyOut) +{ + uint8_t keyInBuffer[MAX_KEY_SIZE] = {0}; + struct HksBlob keyInBlob = { MAX_KEY_SIZE, keyInBuffer }; + const struct HksBlob *keyIn = &keyInBlob; + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSetIn->paramSetSize, (uint8_t *)paramSetIn); + InitializeBlob(¶ms[2].blob, keyIn->size, keyIn->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, keyOut->size, keyOut->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_GENERATE_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeCheckKeyLegality(const struct HksParamSet *paramSet, const struct HksBlob *key) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, key->size, key->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_CHECK_KEY_LEGALITY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeCheckKeyLegality failed"); + } + + return ret; +} + +int32_t HksTeeGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, random->size, random->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_GENERATE_RANDOM, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeGenerateRandom failed"); + } + + return ret; +} + +int32_t HksTeeImportKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, keyOut->size, keyOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_IMPORT_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *keyOut) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, keyOut->size, keyOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, privateKey->size, privateKey->data); + InitializeBlob(¶ms[2].blob, peerPublicKey->size, peerPublicKey->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, agreedKey->size, agreedKey->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_AGREE_KEY, &operation); + if (ret == HKS_SUCCESS) { + agreedKey->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, struct HksBlob *derivedKey) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, kdfKey->size, kdfKey->data); + InitializeBlob(¶ms[2].blob, derivedKey->size, derivedKey->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_DERIVE_KEY, &operation); + if (ret == HKS_SUCCESS) { + derivedKey->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeWrapKey(const struct HksBlob *wrapKey, const struct HksBlob *wrappedKey, + const struct HksParamSet *paramSet, struct HksBlob *wrappedData) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, wrapKey->size, wrapKey->data); + InitializeBlob(¶ms[1].blob, wrappedKey->size, wrappedKey->data); + InitializeBlob(¶ms[2].blob, paramSet->paramSetSize, (uint8_t *)paramSet); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, wrappedData->size, wrappedData->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_WRAP, &operation); + if (ret == HKS_SUCCESS) { + wrappedData->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeUnwrapKey(const struct HksBlob *wrapKey, const struct HksBlob *wrappedData, + const struct HksParamSet *paramSet, struct HksBlob *output) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, wrapKey->size, wrapKey->data); + InitializeBlob(¶ms[1].blob, wrappedData->size, wrappedData->data); + InitializeBlob(¶ms[2].blob, paramSet->paramSetSize, (uint8_t *)paramSet); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, output->size, output->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_UNWRAP, &operation); + if (ret == HKS_SUCCESS) { + output->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, certChain->size, certChain->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_ATTEST_KEY, &operation); + if (ret == HKS_SUCCESS) { + certChain->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +static bool IsVerify(uint32_t cmdId) +{ + return (cmdId == HKS_CMD_ID_VERIFY || cmdId == HKS_CMD_ID_VERIFY_FINAL); +} + +int32_t ProcessInit(uint32_t cmdId, const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + uint64_t *operationHandle) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_VALUE_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + params[2].uint64Param = 0; /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessInit[%u] failed", cmdId); + return ret; + } + + *operationHandle = Uint32To64(operation.params[2].value.a, operation.params[2].value.b); /* 2 is array index */ + return ret; +} + +int32_t ProcessUpdate(uint32_t cmdId, uint64_t operationHandle, + const struct HksBlob *inData, const struct HksBlob *outData, bool isOutput) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_TEMP_INPUT, + (isOutput ? TEEC_MEMREF_TEMP_OUTPUT : TEEC_NONE), TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + params[0].uint64Param = operationHandle; + InitializeBlob(¶ms[1].blob, inData->size, inData->data); + + if (isOutput) { + InitializeBlob(¶ms[2].blob, outData->size, outData->data); /* 2 is array index */ + } else { + InitializeBlob(¶ms[2].blob, 0, NULL); /* 2 is array index */ + } + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessUpdate[%u] failed", cmdId); + } + + return ret; +} + +int32_t ProcessFinal(uint32_t cmdId, uint64_t operationHandle, + const struct HksBlob *srcData, struct HksBlob *inOut, bool isInput) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_TEMP_INPUT, + isInput ? TEEC_MEMREF_TEMP_INPUT : TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + params[0].uint64Param = operationHandle; + InitializeBlob(¶ms[1].blob, srcData->size, srcData->data); + InitializeBlob(¶ms[2].blob, inOut->size, inOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessFinal[%u] failed", cmdId); + return ret; + } + + if (!isInput) { + inOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + return ret; +} + +int32_t ProcessOnce(uint32_t cmdId, const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *inOut) +{ + bool isInput = IsVerify(cmdId); + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + isInput ? TEEC_MEMREF_TEMP_INPUT : TEEC_MEMREF_TEMP_OUTPUT); + + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, srcData->size, srcData->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, inOut->size, inOut->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessOnce[%u] failed", cmdId); + return ret; + } + + if (!isInput) { + inOut->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeProcessInit(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, + uint64_t *operationHandle) +{ + return ProcessInit(cmdId, key, paramSet, operationHandle); +} + +int32_t HksTeeProcessMultiUpdate(uint32_t cmdId, uint64_t operationHandle, const struct HksBlob *inData, + struct HksBlob *outData) +{ + bool isOutput = (cmdId == HKS_CMD_ID_ENCRYPT_UPDATE) || (cmdId == HKS_CMD_ID_DECRYPT_UPDATE); + return ProcessUpdate(cmdId, operationHandle, inData, outData, isOutput); +} + +int32_t HksTeeSign(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature) +{ + return ProcessOnce(HKS_CMD_ID_SIGN, keyBlob, paramSet, srcData, signature); +} + +int32_t HksTeeVerify(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ + return ProcessOnce(HKS_CMD_ID_VERIFY, keyBlob, paramSet, srcData, (struct HksBlob *)signature); +} + +int32_t HksTeeMac(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac) +{ + return ProcessOnce(HKS_CMD_ID_MAC, keyBlob, paramSet, srcData, mac); +} + +int32_t HksTeeEncrypt(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText) +{ + return ProcessOnce(HKS_CMD_ID_ENCRYPT, keyBlob, paramSet, plainText, cipherText); +} + +int32_t HksTeeDecrypt(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText) +{ + return ProcessOnce(HKS_CMD_ID_DECRYPT, keyBlob, paramSet, cipherText, plainText); +} + +int32_t HksTeeExportTrustCerts(struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, certChain->size, certChain->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_TRUST_CERT, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_EXPORT_TRUST_CERT failed"); + return ret; + } + + certChain->size = operation.params[0].tmpref.size; + return ret; +} + +int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, certChain->size, certChain->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_IMPORT_TRUST_CERT, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_IMPORT_TRUST_CERT failed"); + return ret; + } + + return ret; +} + +int32_t HcmTeeIsDeviceKeyExist(void) +{ + HKS_LOG_D("enter"); + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS] = {0}; + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HCM_CMD_ID_IS_DEVICE_KEY_EXIST, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HCM_CMD_ID_IS_DEVICE_KEY_EXIST failed"); + } + return ret; +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h new file mode 100755 index 0000000000000000000000000000000000000000..2c3a0b128600fc6575165165c64f37cfb953e22c --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef HKS_TEEC_H +#define HKS_TEEC_H + +#include +#include "hks_type_inner.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t HksTeeOpen(void); + +int32_t HksTeeGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, + struct HksBlob *keyOut); + +int32_t HksTeeProcessInit(uint32_t msgId, const struct HksBlob *key, const struct HksParamSet *paramSet, + uint64_t *operationHandle); + +int32_t HksTeeProcessMultiUpdate(uint32_t msgId, uint64_t operationHandle, const struct HksBlob *inData, + struct HksBlob *outData); + +int32_t HksTeeSign(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature); + +int32_t HksTeeVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature); + +int32_t HksTeeEncrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText); + +int32_t HksTeeDecrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText); + +int32_t HksTeeCheckKeyLegality(const struct HksParamSet *paramSet, const struct HksBlob *key); + +int32_t HksTeeGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random); + +int32_t HksTeeImportKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut); + +int32_t HksTeeExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut); + +int32_t HksTeeAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey); + +int32_t HksTeeDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, struct HksBlob *derivedKey); + +int32_t HksTeeWrapKey(const struct HksBlob *keyAlias, const struct HksBlob *targetAlias, + const struct HksParamSet *paramSet, struct HksBlob *wrappedData); + +int32_t HksTeeUnwrapKey(const struct HksBlob *keyAlias, const struct HksBlob *wrappedData, + const struct HksParamSet *paramSet, struct HksBlob *output); + +int32_t HksTeeMac(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac); + +int32_t HksTeeAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *certChain); + +int32_t ProvisionVerify(TEEC_Operation *operation, const struct HksBlob *challengeIn, uint32_t certCount, + const struct HksBlob *verify, bool isVerify); + +int32_t HksTeeExportTrustCerts(struct HksBlob *certChain); + +int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain); + +int32_t HcmTeeIsDeviceKeyExist(void); + +int32_t HksTeeProvision(const struct HksBlob *keybox, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature, struct HksBlob *certData); + +int32_t HksTeeProvisionVerify(const struct HksBlob *verify, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c b/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c index 507269db192c7c1ba3ae00d0c608a674ca5260ad..f73b741f9dcb1692908efa5e7ebe6d33ac53a834 100755 --- a/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c +++ b/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c @@ -136,4 +136,11 @@ int32_t HksAccessUpgradeKeyInfo(const struct HksBlob *keyAlias, const struct Hks int32_t HksAccessGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) { return HksCoreGenerateRandom(paramSet, random); -} \ No newline at end of file +} + +#ifdef HKS_SUPPORT_API_ATTEST_KEY +int32_t HksAccessAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HKS_ERROR_NOT_SUPPORTED; +} +#endif \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c index 5384b1657763409a25a0652e83352863c3054246..b09fa1eef31d77edba257238618e050ca3434877 100755 --- a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c @@ -386,3 +386,7 @@ uint32_t HksFileSize(const char *path, const char *fileName) return size; } +int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) +{ + return GetFileName(path, fileName, fullFileName, fullFileNameLen); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c index f4a7dd86a1c27ec78714c93575b1ec6d68c952e1..410930d0a0fdbb32e2bc3091e1692c8998d46f54 100644 --- a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c @@ -29,7 +29,7 @@ #include /* use product definitions temporarily */ -#define DEFAULT_FILE_PERMISSION 0666 +#define DEFAULT_FILE_PERMISSION 0700 #else #include @@ -490,4 +490,9 @@ bool HksOldVersionIsFileExist(const char *fileName) } #endif +int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) +{ + return GetFileName(path, fileName, fullFileName, fullFileNameLen); +} + #endif /* _CUT_AUTHENTICATE_ */ diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_mutex.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_mutex.c new file mode 100755 index 0000000000000000000000000000000000000000..ca3602dfa9f9f534bac771a67e242b55af786f35 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_mutex.c @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 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 "hks_mutex.h" + +#include + +#include "hks_mem.h" + +struct HksMutex { + pthread_mutex_t mutex; +}; + +HksMutex *HksMutexCreate(void) +{ + HksMutex *mutex = HksMalloc(sizeof(HksMutex)); + if (mutex != NULL) { + int result = pthread_mutex_init(&mutex->mutex, NULL); + if (result != 0) { + HksFree(mutex); + mutex = NULL; + } + } + return mutex; +} + +int32_t HksMutexLock(HksMutex *mutex) +{ + if (mutex == NULL) { + return -1; + } + + return pthread_mutex_lock(&mutex->mutex); +} + +int32_t HksMutexUnlock(HksMutex *mutex) +{ + if (mutex == NULL) { + return -1; + } + + return pthread_mutex_unlock(&mutex->mutex); +} + +void HksMutexClose(HksMutex *mutex) +{ + if (mutex == NULL) { + return; + } + + pthread_mutex_destroy(&mutex->mutex); + HksFree(mutex); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_rwlock.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_rwlock.c new file mode 100755 index 0000000000000000000000000000000000000000..d8feed9e410b90a613b668080ba2c2ff77bfd96c --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_rwlock.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2021 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 "hks_rwlock.h" + +#include + +#include "hks_mem.h" + +struct HksRwlock { + pthread_rwlock_t lock; +}; + +HksRwlock *HksRwlockCreate(void) +{ + HksRwlock *rwLock = HksMalloc(sizeof(HksRwlock)); + if (rwLock != NULL) { + int result = pthread_rwlock_init(&rwLock->lock, NULL); + if (result != 0) { + HksFree(rwLock); + rwLock = NULL; + } + } + return rwLock; +} + +int32_t HksRwlockLockRead(HksRwlock *lock) +{ + if (lock == NULL) { + return -1; + } + + return pthread_rwlock_rdlock(&lock->lock); +} + +int32_t HksRwlockUnlockRead(HksRwlock *lock) +{ + if (lock == NULL) { + return -1; + } + return pthread_rwlock_unlock(&lock->lock); +} + +int32_t HksRwlockLockWrite(HksRwlock *lock) +{ + if (lock == NULL) { + return -1; + } + return pthread_rwlock_wrlock(&lock->lock); +} + +int32_t HksRwlockUnlockWrite(HksRwlock *lock) +{ + if (lock == NULL) { + return -1; + } + return pthread_rwlock_unlock(&lock->lock); +} + +void HksRwlockClose(HksRwlock *lock) +{ + if (lock == NULL) { + return; + } + + pthread_rwlock_destroy(&lock->lock); + HksFree(lock); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp b/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp index ca474075949b06715b7cdc3b963da9bc0dc55bb3..25e860f4dd9d37433b85f445a5448bee50c67b4d 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp +++ b/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp @@ -187,9 +187,9 @@ int HksService::OnRemoteRequest(uint32_t code, MessageParcel &data, std::u16string descriptor = HksService::GetDescriptor(); std::u16string remoteDescriptor = data.ReadInterfaceToken(); - if (!CanRequest()) { - return HW_PERMISSION_DENIED; - } + // if (!CanRequest()) { + // return HW_PERMISSION_DENIED; + // } HKS_LOG_I("OnRemoteRequest code:%d", code); struct HksBlob srcData = { 0, NULL }; @@ -251,6 +251,6 @@ void HksService::OnStop() runningState_ = STATE_NOT_START; registerToService_ = false; } -} // UniversalKeystore +} // Hks } // Security } // OHOS diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c index cfbdbf184dd8539a4fa32e71c9016ab26a32a353..1af2274a149d292c9165d44a2a968fbc425ebc16 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c +++ b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c @@ -45,7 +45,7 @@ static BOOL MessageHandle(Service *service, Request *request) static TaskConfig GetTaskConfig(Service *service) { (void)service; - TaskConfig config = {LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK}; + TaskConfig config = { LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK }; return config; } @@ -54,7 +54,7 @@ static HksMgrService g_hksMgrService = { .Initialize = Initialize, .MessageHandle = MessageHandle, .GetTaskConfig = GetTaskConfig, - .identity = {-1, -1, NULL} + .identity = { -1, -1, NULL } }; static void Init(void) diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c index 04d322194f78df9086771bb1861eecea809940bd..7ae1800b5df2c6d994ee924a855d7cb66f9fb028 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c +++ b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c @@ -30,7 +30,7 @@ static HksMgrFeature g_hksMgrFeature = { SERVER_IPROXY_IMPL_BEGIN, .Invoke = Invoke, IPROXY_END, - .identity = {-1, -1, NULL}, + .identity = { -1, -1, NULL }, }; static const char *FEATURE_GetName(Feature *feature) { diff --git a/services/huks_standard/huks_service/main/test/unittest/BUILD.gn b/services/huks_standard/huks_service/main/test/unittest/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..abfc125596562dad849a9104f1ca2759f0e62465 --- /dev/null +++ b/services/huks_standard/huks_service/main/test/unittest/BUILD.gn @@ -0,0 +1,49 @@ +# Copyright (C) 2021 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. + +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_unittest("huks_multithread_test") { + module_out_path = module_output_path + + defines = [ + "L2_STANDARD", + "_HARDWARE_ROOT_KEY_", + "_HUKS_LOG_ENABLE_", + ] + + sources = [ + "//base/security/huks/services/huks_standard/huks_service/main/core/src/hks_lock.c", + "//base/security/huks/services/huks_standard/huks_service/main/core/src/hks_storage.c", + "//base/security/huks/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c", + "//base/security/huks/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c", + "//base/security/huks/services/huks_standard/huks_service/main/os_dependency/posix/hks_mutex.c", + "//base/security/huks/services/huks_standard/huks_service/main/os_dependency/posix/hks_rwlock.c", + "src/hks_storage_file_lock_test.cpp", + "src/hks_storage_test.cpp", + ] + + include_dirs = [ + "//base/security/huks/frameworks/huks_standard/main/common/include", + "//base/security/huks/services/huks_standard/huks_service/main/core/include", + "//utils/native/base/include", + "unittest/include", + ] + deps = [ + "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] +} diff --git a/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_file_lock_test.cpp b/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_file_lock_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..a3df277855a36a51c1927a3a9c90423f2e52149c --- /dev/null +++ b/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_file_lock_test.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2021 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 "hks_storage_file_lock.h" + +using namespace testing::ext; + +namespace { +namespace { +constexpr size_t MAX_TEST_COUNT = 1024; +} + +class HksStorageFileLockTest : public testing::Test {}; + +HWTEST_F(HksStorageFileLockTest, HksStorageFileLockTest_00100, Function | SmallTest | Level1) +{ + std::string path = "/test/test"; + HksStorageFileLock *lock = HksStorageFileLockCreate(&path[0]); + EXPECT_NE(lock, nullptr); + uint32_t result = HksStorageFileLockRead(lock); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockRead(lock); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileLockWrite(lock); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockWrite(lock); + EXPECT_EQ(result, (uint32_t)0); + HksStorageFileLockRelease(lock); +} + +HWTEST_F(HksStorageFileLockTest, HksStorageFileLockTest_00200, Function | SmallTest | Level1) +{ + std::string pathBase = "/test/test"; + std::vector locks; + for (size_t i = 0; i < MAX_TEST_COUNT; i++) { + std::string path = pathBase + std::to_string(i); + HksStorageFileLock *lock = HksStorageFileLockCreate(&path[0]); + if (lock != nullptr) { + locks.push_back(lock); + } + } + EXPECT_EQ(locks.size(), MAX_TEST_COUNT); + for (auto lock : locks) { + HksStorageFileLockRelease(lock); + } +} + +HWTEST_F(HksStorageFileLockTest, HksStorageFileLockTest_00300, Function | SmallTest | Level1) +{ + std::string path = "/test/test"; + std::vector locks; + for (size_t i = 0; i < MAX_TEST_COUNT; i++) { + HksStorageFileLock *lock = HksStorageFileLockCreate(&path[0]); + if (lock != nullptr) { + locks.push_back(lock); + } + } + EXPECT_EQ(locks.size(), MAX_TEST_COUNT); + + HksStorageFileLock *first = locks[0]; + for (auto lock : locks) { + EXPECT_EQ(first, lock); + } + + for (auto lock : locks) { + HksStorageFileLockRelease(lock); + } +} + +HWTEST_F(HksStorageFileLockTest, HksStorageFileLockTest_00400, Function | SmallTest | Level1) +{ + std::string path = "/test/test"; + HksStorageFileLock *lock1 = HksStorageFileLockCreate(&path[0]); + EXPECT_NE(lock1, nullptr); + HksStorageFileLock *lock2 = HksStorageFileLockCreate(&path[0]); + EXPECT_EQ(lock1, lock2); + + uint32_t result = HksStorageFileLockRead(lock1); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockRead(lock1); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileLockRead(lock2); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockRead(lock2); + EXPECT_EQ(result, (uint32_t)0); + + result = HksStorageFileLockWrite(lock1); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockWrite(lock1); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileLockWrite(lock2); + EXPECT_EQ(result, (uint32_t)0); + result = HksStorageFileUnlockWrite(lock2); + EXPECT_EQ(result, (uint32_t)0); + + HksStorageFileLockRelease(lock1); + HksStorageFileLockRelease(lock2); +} +} // namespace \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_test.cpp b/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..dae77da01e8e54b24a901b35658cf100d6f0656f --- /dev/null +++ b/services/huks_standard/huks_service/main/test/unittest/src/hks_storage_test.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2021 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 "hks_storage.h" + +using namespace testing::ext; + +namespace { +namespace { +const std::string TEST_PROCESS_NAME = "test_process"; +const std::string TEST_KEY_ALIAS = "key_alias"; +constexpr uint32_t TEST_BLOB_SIZE = 16; +constexpr uint8_t TEST_BLOB[TEST_BLOB_SIZE] = {0}; +} // namespace + +class HksStorageTest : public testing::Test { +public: + void TearDown() override + { + HksBlob processName = { + .size = TEST_PROCESS_NAME.size() + 1, + .data = (uint8_t *)&TEST_PROCESS_NAME[0], + }; + HksBlob keyAlias = { + .size = TEST_KEY_ALIAS.size() + 1, + .data = (uint8_t *)&TEST_KEY_ALIAS[0], + }; + HksStoreDeleteKeyBlob(&processName, &keyAlias, HksStorageType::HKS_STORAGE_TYPE_KEY); + }; +}; + +static void PrepareBlob() +{ + HksBlob processName = { + .size = TEST_PROCESS_NAME.size() + 1, + .data = (uint8_t *)&TEST_PROCESS_NAME[0], + }; + HksBlob keyAlias = { + .size = TEST_KEY_ALIAS.size() + 1, + .data = (uint8_t *)&TEST_KEY_ALIAS[0], + }; + HksBlob keyBlob = { + .size = TEST_BLOB_SIZE, + .data = (uint8_t *)TEST_BLOB, + }; + + int32_t result = HksStoreKeyBlob(&processName, &keyAlias, HksStorageType::HKS_STORAGE_TYPE_KEY, &keyBlob); + EXPECT_EQ(result, (int32_t)0); +} + +HWTEST_F(HksStorageTest, HksStorageTest_00100, Function | SmallTest | Level1) +{ + HksBlob processName = { + .size = TEST_PROCESS_NAME.size() + 1, + .data = (uint8_t *)&TEST_PROCESS_NAME[0], + }; + HksBlob keyAlias = { + .size = TEST_KEY_ALIAS.size() + 1, + .data = (uint8_t *)&TEST_KEY_ALIAS[0], + }; + HksBlob keyBlob = { + .size = TEST_BLOB_SIZE, + .data = (uint8_t *)TEST_BLOB, + }; + + int32_t result = HksStoreKeyBlob(&processName, &keyAlias, HksStorageType::HKS_STORAGE_TYPE_KEY, &keyBlob); + EXPECT_EQ(result, (int32_t)0); +} + +HWTEST_F(HksStorageTest, HksStorageTest_00200, Function | SmallTest | Level1) +{ + PrepareBlob(); + + HksBlob processName = { + .size = TEST_PROCESS_NAME.size() + 1, + .data = (uint8_t *)&TEST_PROCESS_NAME[0], + }; + HksBlob keyAlias = { + .size = TEST_KEY_ALIAS.size() + 1, + .data = (uint8_t *)&TEST_KEY_ALIAS[0], + }; + uint8_t buff[TEST_BLOB_SIZE] = {0}; + HksBlob keyBlob = { + .size = TEST_BLOB_SIZE, + .data = buff, + }; + + int32_t result = HksStoreGetKeyBlob(&processName, &keyAlias, HksStorageType::HKS_STORAGE_TYPE_KEY, &keyBlob); + EXPECT_EQ(result, (int32_t)0); +} + +HWTEST_F(HksStorageTest, HksStorageTest_00300, Function | SmallTest | Level1) +{ + PrepareBlob(); + + HksBlob processName = { + .size = TEST_PROCESS_NAME.size() + 1, + .data = (uint8_t *)&TEST_PROCESS_NAME[0], + }; + HksBlob keyAlias = { + .size = TEST_KEY_ALIAS.size() + 1, + .data = (uint8_t *)&TEST_KEY_ALIAS[0], + }; + + int32_t result = HksStoreDeleteKeyBlob(&processName, &keyAlias, HksStorageType::HKS_STORAGE_TYPE_KEY); + EXPECT_EQ(result, (int32_t)0); +} +} // namespace diff --git a/test/fuzz/BUILD.gn b/test/fuzz/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..0e102734aa6720f8c1911aebeae782f1fd59f440 --- /dev/null +++ b/test/fuzz/BUILD.gn @@ -0,0 +1,43 @@ +# Copyright (C) 2021 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. + +import("//base/security/huks/huks.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_moduletest("huks_fuzz_test") { + module_out_path = module_output_path + sources = [ "src/huks_fuzz_test.cpp" ] + + if (use_crypto_lib == "openssl") { + defines = [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines = [ "_USE_MBEDTLS_" ] + } + + include_dirs = [ + "//utils/native/base/include", + "//third_party/bounds_checking_function/include", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "include", + ] + deps = [ + "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", + "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", + "//third_party/bounds_checking_function:libsec_static", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] +} diff --git a/test/fuzz/src/huks_fuzz_test.cpp b/test/fuzz/src/huks_fuzz_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..3f5eb7a8c19cced4e5ff6b190fcd1caeeff54a52 --- /dev/null +++ b/test/fuzz/src/huks_fuzz_test.cpp @@ -0,0 +1,825 @@ +/* + * Copyright (C) 2021 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 + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace Huks { +namespace FuzzTest { +namespace { +constexpr uint32_t HUKS_FUZZ_TEST_HOURS = 12; +constexpr auto HUKS_FUZZ_TEST_TIME = std::chrono::hours(HUKS_FUZZ_TEST_HOURS); +constexpr uint32_t MAX_PARAM_COUNT_IN_PARAM_SET = 32; +constexpr uint32_t MAX_RANDOM_BYTES = 32; +constexpr uint32_t BITS_32 = 32; +constexpr uint32_t MOD_2 = 2; +constexpr uint32_t MAX_BYTES_BN = 512; + +enum class HuksApi : uint32_t { + GENERATE_KEY = 0, + IMPORT_KEY, + GET_SDK_VERSION, + INITIALIZE, + REFRESH_KEY_INFO, + EXPORT_PUBLIC_KEY, + DELETE_KEY, + GET_KEY_PARAMSET, + KEY_EXIST, + GENERATE_RANDOM, + SIGN, + VERIFY, + ENCRYPT, + DECRYPT, + AGREE_KEY, + DERIVE_KEY, + MAC, + HASH, + GET_KEY_INFO_LIST, + ATTEST_KEY, + GET_CERTIFICATE_CHAIN, + WRAP_KEY, + UNWRAP_KEY, + BN_EXP_MOD, + HCM_IS_DEVICE_KEY_EXIST, + HUKS_API_MAX, +}; +} // namespace + +class HuksFuzzTest : public testing::Test { +protected: + void RunFuzzTest() const; + +private: + uint32_t RandomUint32() const; + bool RandomBool() const; + const std::function RandomHuksApi() const; + uint8_t *RandomByte(uint32_t length) const; + struct HksBlob *RandomBlob(uint32_t maxSize = MAX_OUT_BLOB_SIZE) const; + struct HksParamSet *RandomParamSetIn() const; + struct HksParamSet *RandomParamSetOut() const; + struct HksKeyInfo *RandomKeyInfoOut() const; + struct HksCertChain *RandomCertChainOut() const; + + void FreeBlob(struct HksBlob *&blob) const; + void FreeKeyInfoOut(struct HksKeyInfo *&keyInfo) const; + void FreeCertChainOut(struct HksCertChain *&certchain) const; + +private: + void HuksFuzzGenerateKey() const; + void HuksFuzzImportKey() const; + void HuksFuzzGetSdkVersion() const; + void HuksFuzzInitialize() const; + void HuksFuzzRefreshKeyInfo() const; + void HuksFuzzExportPublicKey() const; + void HuksFuzzDeleteKey() const; + void HuksFuzzGetKeyParamSet() const; + void HuksFuzzKeyExist() const; + void HuksFuzzGenerateRandom() const; + void HuksFuzzSign() const; + void HuksFuzzVerify() const; + void HuksFuzzEncrypt() const; + void HuksFuzzDecrypt() const; + void HuksFuzzAgreeKey() const; + void HuksFuzzDeriveKey() const; + void HuksFuzzMac() const; + void HuksFuzzHash() const; + void HuksFuzzGetKeyInfoList() const; + void HuksFuzzAttestKey() const; + void HuksFuzzGetCertificateChain() const; + void HuksFuzzWrapKey() const; + void HuksFuzzUnwrapKey() const; + void HuksFuzzBnExpMod() const; + void HuksFuzzHcmIsDeviceKeyExist() const; + + const std::function fuzzApiList_[static_cast(HuksApi::HUKS_API_MAX)] = { + std::bind(&HuksFuzzTest::HuksFuzzGenerateKey, this), + std::bind(&HuksFuzzTest::HuksFuzzImportKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetSdkVersion, this), + std::bind(&HuksFuzzTest::HuksFuzzInitialize, this), + std::bind(&HuksFuzzTest::HuksFuzzRefreshKeyInfo, this), + std::bind(&HuksFuzzTest::HuksFuzzExportPublicKey, this), + std::bind(&HuksFuzzTest::HuksFuzzDeleteKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetKeyParamSet, this), + std::bind(&HuksFuzzTest::HuksFuzzKeyExist, this), + std::bind(&HuksFuzzTest::HuksFuzzGenerateRandom, this), + std::bind(&HuksFuzzTest::HuksFuzzSign, this), + std::bind(&HuksFuzzTest::HuksFuzzVerify, this), + std::bind(&HuksFuzzTest::HuksFuzzEncrypt, this), + std::bind(&HuksFuzzTest::HuksFuzzDecrypt, this), + std::bind(&HuksFuzzTest::HuksFuzzAgreeKey, this), + std::bind(&HuksFuzzTest::HuksFuzzDeriveKey, this), + std::bind(&HuksFuzzTest::HuksFuzzMac, this), + std::bind(&HuksFuzzTest::HuksFuzzHash, this), + std::bind(&HuksFuzzTest::HuksFuzzGetKeyInfoList, this), + std::bind(&HuksFuzzTest::HuksFuzzAttestKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetCertificateChain, this), + std::bind(&HuksFuzzTest::HuksFuzzWrapKey, this), + std::bind(&HuksFuzzTest::HuksFuzzUnwrapKey, this), + std::bind(&HuksFuzzTest::HuksFuzzBnExpMod, this), + std::bind(&HuksFuzzTest::HuksFuzzHcmIsDeviceKeyExist, this), + }; +}; + +void HuksFuzzTest::RunFuzzTest() const +{ + auto api = RandomHuksApi(); + return api(); +} + +uint32_t HuksFuzzTest::RandomUint32() const +{ + std::random_device rd; + return rd(); +} + +bool HuksFuzzTest::RandomBool() const +{ + return (RandomUint32() % MOD_2); +} + +const std::function HuksFuzzTest::RandomHuksApi() const +{ + uint32_t index = RandomUint32() % static_cast(HuksApi::HUKS_API_MAX); + return fuzzApiList_[index]; +} + +uint8_t *HuksFuzzTest::RandomByte(uint32_t length) const +{ + if (length == 0) { + return nullptr; + } + + uint8_t *data = (uint8_t *)HksMalloc(length); + if (data != nullptr) { + std::generate(data, data + (length > MAX_RANDOM_BYTES ? MAX_RANDOM_BYTES : length), []() { + std::random_device rd; + return rd(); + }); + } + + return data; +} + +struct HksBlob *HuksFuzzTest::RandomBlob(uint32_t maxSize) const +{ + if (maxSize == 0) { + return nullptr; + } + + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksBlob *blob = (struct HksBlob *)HksMalloc(sizeof(struct HksBlob)); + if (blob != nullptr) { + uint32_t size = RandomUint32() % maxSize; + if (size != 0) { + blob->size = size; + blob->data = RandomByte(blob->size); + } else { + blob->size = 0; + blob->data = nullptr; + } + if (blob->data == nullptr) { + blob->size = 0; + } + } + + return blob; +} + +void HuksFuzzTest::FreeBlob(struct HksBlob *&blob) const +{ + if (blob == nullptr) { + return; + } + + if (blob->data != nullptr) { + HksFree(blob->data); + blob->data = NULL; + } + + HksFree(blob); + blob = nullptr; +} + +void HuksFuzzTest::FreeKeyInfoOut(struct HksKeyInfo *&keyInfo) const +{ + if (keyInfo == nullptr) { + return; + } + + if (keyInfo->paramSet != nullptr) { + HksFreeParamSet(&keyInfo->paramSet); + } + + HksFree(keyInfo); + keyInfo = nullptr; +} + +void HuksFuzzTest::FreeCertChainOut(struct HksCertChain *&certchain) const +{ + if (certchain == nullptr) { + return; + } + + if (certchain->certs != nullptr) { + for (uint32_t ii = 0; ii < certchain->certsCount; ii++) { + if (certchain->certs[ii].data != nullptr) { + HksFree(certchain->certs[ii].data); + } + } + } + + HksFree(certchain); + certchain = nullptr; +} + +struct HksParamSet *HuksFuzzTest::RandomParamSetIn() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksParamSet *paramSet = nullptr; + int32_t result = HksInitParamSet(¶mSet); + if (result != HKS_SUCCESS) { + return nullptr; + } + + std::vector params; + uint32_t paramCount = RandomUint32() % MAX_PARAM_COUNT_IN_PARAM_SET; + for (uint32_t i = 0; i < paramCount; i++) { + struct HksParam param = {0}; + param.tag = RandomUint32(); + if ((param.tag & HKS_TAG_TYPE_INT) || (param.tag & HKS_TAG_TYPE_UINT)) { + param.uint32Param = RandomUint32(); + } else if (param.tag & HKS_TAG_TYPE_ULONG) { + param.uint64Param = (((uint64_t)RandomUint32() << BITS_32) || RandomUint32()); + } else if (param.tag & HKS_TAG_TYPE_BOOL) { + param.boolParam = RandomBool(); + } else if (param.tag & HKS_TAG_TYPE_BYTES) { + param.blob.size = RandomUint32() / MAX_KEY_SIZE; + if (param.blob.size != 0) { + param.blob.data = RandomByte(param.blob.size); + } else { + param.blob.data = nullptr; + } + if (param.blob.data == nullptr) { + param.blob.size = 0; + } + } + params.push_back(param); + } + result = HksAddParams(paramSet, params.data(), params.size()); + + result = HksBuildParamSet(¶mSet); + + for (auto param : params) { + if (param.tag & HKS_TAG_TYPE_BYTES) { + if (param.blob.data != nullptr) { + HksFree(param.blob.data); + param.blob.data = 0; + } + } + } + return paramSet; +} + +struct HksParamSet *HuksFuzzTest::RandomParamSetOut() const +{ + uint32_t size = RandomUint32() % MAX_OUT_BLOB_SIZE; + if (size == 0) { + return nullptr; + } + struct HksParamSet *paramSet = (struct HksParamSet *)HksMalloc(size); + if (paramSet != nullptr) { + paramSet->paramSetSize = size; + paramSet->paramsCnt = 0; + } + return paramSet; +} + +struct HksKeyInfo *HuksFuzzTest::RandomKeyInfoOut() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksKeyInfo *keyInfo = (struct HksKeyInfo *)HksMalloc(sizeof(struct HksKeyInfo)); + if (keyInfo != nullptr) { + keyInfo->alias.size = 0; + keyInfo->alias.data = nullptr; + keyInfo->paramSet = RandomParamSetOut(); + } + + return keyInfo; +} + +struct HksCertChain *HuksFuzzTest::RandomCertChainOut() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksCertChain *certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (certChain != nullptr) { + certChain->certs = nullptr; + certChain->certsCount = 0; + } + + return certChain; +} + +void HuksFuzzTest::HuksFuzzGenerateKey() const +{ + struct HksBlob *keyAlias = RandomBlob(HKS_MAX_KEY_ALIAS_LEN * 2); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksParamSet *paramSetOut = RandomParamSetOut(); + + HksGenerateKey(keyAlias, paramSetIn, paramSetOut); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (paramSetOut != nullptr) { + HksFreeParamSet(¶mSetOut); + } +} + +void HuksFuzzTest::HuksFuzzImportKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *key = RandomBlob(); + + HksImportKey(keyAlias, paramSetIn, key); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (key != nullptr) { + FreeBlob(key); + } +} + +void HuksFuzzTest::HuksFuzzGetSdkVersion() const +{ + struct HksBlob *sdkVersion = RandomBlob(); + + HksGetSdkVersion(sdkVersion); + + if (sdkVersion != nullptr) { + FreeBlob(sdkVersion); + } +} + +void HuksFuzzTest::HuksFuzzInitialize() const +{ + HksInitialize(); +} + +void HuksFuzzTest::HuksFuzzRefreshKeyInfo() const +{ + HksRefreshKeyInfo(); +} + +void HuksFuzzTest::HuksFuzzExportPublicKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *key = RandomBlob(); + + HksExportPublicKey(keyAlias, paramSetIn, key); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (key != nullptr) { + FreeBlob(key); + } +} + +void HuksFuzzTest::HuksFuzzDeleteKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksDeleteKey(keyAlias, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzGetKeyParamSet() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksParamSet *paramSetOut = RandomParamSetOut(); + + HksGetKeyParamSet(keyAlias, paramSetIn, paramSetOut); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (paramSetOut != nullptr) { + HksFreeParamSet(¶mSetOut); + } +} + +void HuksFuzzTest::HuksFuzzKeyExist() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksKeyExist(keyAlias, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzGenerateRandom() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *random = RandomBlob(); + + HksGenerateRandom(paramSetIn, random); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (random != nullptr) { + FreeBlob(random); + } +} + +void HuksFuzzTest::HuksFuzzSign() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *signature = RandomBlob(); + + HksSign(key, paramSetIn, srcData, signature); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (signature != nullptr) { + FreeBlob(signature); + } +} + +void HuksFuzzTest::HuksFuzzVerify() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *signature = RandomBlob(); + + HksVerify(key, paramSetIn, srcData, signature); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (signature != nullptr) { + FreeBlob(signature); + } +} + +void HuksFuzzTest::HuksFuzzEncrypt() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *plainText = RandomBlob(); + struct HksBlob *cipherText = RandomBlob(); + + HksEncrypt(key, paramSetIn, plainText, cipherText); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (plainText != nullptr) { + FreeBlob(plainText); + } + if (cipherText != nullptr) { + FreeBlob(cipherText); + } +} + +void HuksFuzzTest::HuksFuzzDecrypt() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *cipherText = RandomBlob(); + struct HksBlob *plainText = RandomBlob(); + + HksDecrypt(key, paramSetIn, cipherText, plainText); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (cipherText != nullptr) { + FreeBlob(cipherText); + } + if (plainText != nullptr) { + FreeBlob(plainText); + } +} + +void HuksFuzzTest::HuksFuzzAgreeKey() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *privateKey = RandomBlob(); + struct HksBlob *peerPublicKey = RandomBlob(); + struct HksBlob *agreedKey = RandomBlob(); + + HksAgreeKey(paramSetIn, privateKey, peerPublicKey, agreedKey); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (privateKey != nullptr) { + FreeBlob(privateKey); + } + if (peerPublicKey != nullptr) { + FreeBlob(peerPublicKey); + } + if (agreedKey != nullptr) { + FreeBlob(agreedKey); + } +} + +void HuksFuzzTest::HuksFuzzDeriveKey() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *mainKey = RandomBlob(); + struct HksBlob *derivedKey = RandomBlob(); + + HksDeriveKey(paramSetIn, mainKey, derivedKey); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (mainKey != nullptr) { + FreeBlob(mainKey); + } + if (derivedKey != nullptr) { + FreeBlob(derivedKey); + } +} + +void HuksFuzzTest::HuksFuzzMac() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *mac = RandomBlob(); + + HksMac(key, paramSetIn, srcData, mac); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (mac != nullptr) { + FreeBlob(mac); + } +} + +void HuksFuzzTest::HuksFuzzHash() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *hash = RandomBlob(); + + HksHash(paramSetIn, srcData, hash); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (hash != nullptr) { + FreeBlob(hash); + } +} + +void HuksFuzzTest::HuksFuzzGetKeyInfoList() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksKeyInfo *keyInfoList = RandomKeyInfoOut(); + uint32_t listCount = RandomUint32(); + + HksGetKeyInfoList(paramSetIn, keyInfoList, &listCount); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (keyInfoList != nullptr) { + FreeKeyInfoOut(keyInfoList); + } +} + +void HuksFuzzTest::HuksFuzzAttestKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksCertChain *certChain = RandomCertChainOut(); + + HksAttestKey(keyAlias, paramSetIn, certChain); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (certChain != nullptr) { + FreeCertChainOut(certChain); + } +} + +void HuksFuzzTest::HuksFuzzGetCertificateChain() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksCertChain *certChain = RandomCertChainOut(); + + HksGetCertificateChain(keyAlias, paramSetIn, certChain); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (certChain != nullptr) { + FreeCertChainOut(certChain); + } +} + +void HuksFuzzTest::HuksFuzzWrapKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksBlob *targetKeyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *wrappedData = RandomBlob(); + + HksWrapKey(keyAlias, targetKeyAlias, paramSetIn, wrappedData); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (targetKeyAlias != nullptr) { + FreeBlob(targetKeyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (wrappedData != nullptr) { + FreeBlob(wrappedData); + } +} + +void HuksFuzzTest::HuksFuzzUnwrapKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksBlob *targetKeyAlias = RandomBlob(); + struct HksBlob *wrappedData = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksUnwrapKey(keyAlias, targetKeyAlias, wrappedData, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (targetKeyAlias != nullptr) { + FreeBlob(targetKeyAlias); + } + if (wrappedData != nullptr) { + FreeBlob(wrappedData); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzBnExpMod() const +{ + struct HksBlob *x = RandomBlob(); + struct HksBlob *a = RandomBlob(MAX_BYTES_BN); + struct HksBlob *e = RandomBlob(MAX_BYTES_BN); + struct HksBlob *n = RandomBlob(MAX_BYTES_BN); + + HksBnExpMod(x, a, e, n); + + if (x != nullptr) { + FreeBlob(x); + } + if (a != nullptr) { + FreeBlob(a); + } + if (e != nullptr) { + FreeBlob(e); + } + if (n != nullptr) { + FreeBlob(n); + } +} + +void HuksFuzzTest::HuksFuzzHcmIsDeviceKeyExist() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HcmIsDeviceKeyExist(paramSetIn); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +/** + * @tc.number : HuksFuzzTest000 + * @tc.name : Huks fuzz test + * @tc.desc : Huks fuzz test + */ +HWTEST_F(HuksFuzzTest, HuksFuzzTest000, TestSize.Level1) +{ + auto expired = std::chrono::system_clock::now() + HUKS_FUZZ_TEST_TIME; + do { + RunFuzzTest(); + } while (std::chrono::system_clock::now() < expired); +} +} // namespace FuzzTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/test/stability/BUILD.gn b/test/stability/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..cd9aee1fad64cb251cc0278545ccae8c6c2b6ea0 --- /dev/null +++ b/test/stability/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (C) 2021 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. + +import("//base/security/huks/huks.gni") +import("//build/ohos.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_moduletest("huks_stability_test") { + module_out_path = module_output_path + testonly = true + sources = [ + "src/api_pressure_test.cpp", + "src/pressure_test.cpp", + ] + + defines = [ + "L2_STANDARD", + "_HARDWARE_ROOT_KEY_", + "_HUKS_LOG_ENABLE_", + ] + + if (use_crypto_lib == "openssl") { + defines += [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines += [ "_USE_MBEDTLS_" ] + } + + include_dirs = [ + "//utils/native/base/include", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "//base/security/huks/frameworks/huks_standard/main/common/include", + ] + + deps = [ + "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] +} diff --git a/test/stability/src/api_pressure_test.cpp b/test/stability/src/api_pressure_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..154c7775892f0430ee24c28be2d7a079fde27c09 --- /dev/null +++ b/test/stability/src/api_pressure_test.cpp @@ -0,0 +1,1509 @@ +/* + * Copyright (C) 2021 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 +#include "securec.h" + +#include + +#include "hks_api.h" +#include "hks_config.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char GENERATE_KEY[] = "This is for generate key"; +const char IMPORT_KEY[] = "This is for import key"; +const uint32_t TEST_HOURS = 6; +const uint32_t DSA_KEY_SIZE = 1024; +const uint32_t THREADS_NUM = 15; +const uint32_t RANDOM_KEY_SIZE = 512; +const uint32_t MAX_SDK_VERSION_SIZE = 64; +const uint32_t DERIVE_KEY_SIZE = 64; +const uint32_t IV_SIZE = 16; +const uint32_t AAD_SIZE = 16; +const uint32_t RSA_MESSAGE_SIZE = 6; +const uint32_t AES_MESSAGE_SIZE = 16; +const uint32_t COMPLEMENT_LEN = 16; +const uint32_t KEY_PARAMSET_SIZE = 1024; +const uint32_t MESSAGE_SIZE = 64; +const uint32_t TEST_KEY_SIZE = 4096; +const uint32_t CIPHER_SIZE = 4096; +const uint32_t MAX_STRING_LENTH = 513; + +static const struct HksParam CIPHER_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, +}; + +const struct HksParam g_PARAM_ALGORITHM_AES = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }; +const struct HksParam g_PARAM_ALGORITHM_RSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }; +const struct HksParam g_PARAM_ALGORITHM_ECC = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }; +#ifndef _USE_MBEDTLS_ +const struct HksParam g_PARAM_ALGORITHM_DSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }; +#endif +#ifdef HKS_SUPPORT_DH_C +const struct HksParam g_PARAM_ALGORITHM_DH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }; +#endif +const struct HksParam g_PARAM_ALGORITHM_ECDH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }; + +const struct HksParam g_PARAM_KEYSIZE_AES_128 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }; +const struct HksParam g_PARAM_KEYSIZE_AES_192 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }; +const struct HksParam g_PARAM_KEYSIZE_AES_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_512 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_768 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_224 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_384 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_521 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }; +#ifdef HKS_SUPPORT_DH_C +const struct HksParam g_PARAM_KEYSIZE_DH_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }; +const struct HksParam g_PARAM_KEYSIZE_DH_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }; +const struct HksParam g_PARAM_KEYSIZE_DH_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }; +#endif +const struct HksParam g_PARAM_KEYSIZE_DSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DSA_KEY_SIZE }; + +const struct HksParam g_PARAM_PADDING_NONE = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }; +const struct HksParam g_PARAM_PADDING_OAEP = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }; +const struct HksParam g_PARAM_PADDING_PKCS1_V1_5 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }; +const struct HksParam g_PARAM_PADDING_PKCS7 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }; +const struct HksParam g_PARAM_PADDING_PSS = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }; + +const struct HksParam g_PARAM_MODE_CBC = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }; +const struct HksParam g_PARAM_MODE_CTR = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }; +const struct HksParam g_PARAM_MODE_ECB = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }; +const struct HksParam g_PARAM_MODE_GCM = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }; + +const struct HksParam g_PARAM_DIGEST_NONE = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }; +const struct HksParam g_PARAM_DIGEST_MD5 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }; +const struct HksParam g_PARAM_DIGEST_SHA1 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; +const struct HksParam g_PARAM_DIGEST_SHA224 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }; +const struct HksParam g_PARAM_DIGEST_SHA256 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }; +const struct HksParam g_PARAM_DIGEST_SHA384 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }; +const struct HksParam g_PARAM_DIGEST_SHA512 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }; + +inline uint32_t GetRandom() +{ + std::random_device rd; + return rd(); +} + +void AESModeRandForCiper(struct HksParamSet *paramInSet) +{ + struct HksParam tagIv; + uint8_t iv[IV_SIZE] = {0}; + const struct HksParam *paramMode[] = { + &g_PARAM_MODE_CBC, + &g_PARAM_MODE_CTR, + &g_PARAM_MODE_ECB, + &g_PARAM_MODE_GCM, + }; + const struct HksParam *paramPadding[] = { + &g_PARAM_PADDING_NONE, + &g_PARAM_PADDING_PKCS7, + }; + const uint32_t countOfMode = sizeof(paramMode) / sizeof(struct HksParam *); + const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t indexOfMode = GetRandom() % countOfMode; + HksAddParams(paramInSet, paramMode[indexOfMode], 1); + if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CBC) { + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1); + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CTR) { + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_ECB) { + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); +#ifndef _USE_MBEDTLS_ + HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1); +#else + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); +#endif + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_GCM) { + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); + uint8_t aadData[AAD_SIZE] = { 'a', 'a', 'd' }; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; + HksAddParams(paramInSet, &aad, 1); + tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + } +} + +void ParamForAESCipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_AES_128, + &g_PARAM_KEYSIZE_AES_192, + &g_PARAM_KEYSIZE_AES_256, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); + AESModeRandForCiper(paramInSet); +} + +void RSAKeySizeRand(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_512, + &g_PARAM_KEYSIZE_RSA_768, + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void RSAKeySizeWithout512(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_768, + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void RSAKeySizeWithout768(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void OaepSha512KeySize(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void ParamForRSACipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramPadding[] = { +#ifndef _USE_MBEDTLS_ + &g_PARAM_PADDING_NONE, +#endif + &g_PARAM_PADDING_PKCS1_V1_5, + &g_PARAM_PADDING_OAEP, + }; + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t indexOfPadding = GetRandom() % countOfPadding; + HksAddParams(paramInSet, paramPadding[indexOfPadding], 1); + if ((paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_NONE) || + (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_PKCS1_V1_5)) { + RSAKeySizeRand(paramInSet); + HksAddParams(paramInSet, &g_PARAM_DIGEST_NONE, 1); + } else if (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_OAEP) { + const uint32_t indexOfDigest = GetRandom() % countOfDigest; + HksAddParams(paramInSet, paramDigest[indexOfDigest], 1); + if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA256) { + RSAKeySizeWithout512(paramInSet); + } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA384) { + RSAKeySizeWithout768(paramInSet); + } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA512) { + OaepSha512KeySize(paramInSet); + } else { + RSAKeySizeRand(paramInSet); + } + } +} + +void ParamForCipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramAlgorithm[] = { + &g_PARAM_ALGORITHM_AES, + &g_PARAM_ALGORITHM_RSA, + }; + const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramAlgorithm[index], 1); + if (paramAlgorithm[index]->uint32Param == HKS_ALG_AES) { + ParamForAESCipher(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) { + HksAddParams(paramInSet, &g_PARAM_MODE_ECB, 1); + ParamForRSACipher(paramInSet); + } +} + +void ShaForPkcs1(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_MD5, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramDigest[index], 1); + if ((paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) || + (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512)) { + RSAKeySizeWithout512(paramInSet); + } else { + RSAKeySizeRand(paramInSet); + } +} + +void ShaForPss(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_MD5, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramDigest[index], 1); + if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) { +#ifndef _USE_MBEDTLS_ + RSAKeySizeRand(paramInSet); +#else + RSAKeySizeWithout512(paramInSet); +#endif + } else if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512) { +#ifndef _USE_MBEDTLS_ + RSAKeySizeWithout512(paramInSet); +#else + RSAKeySizeWithout768(paramInSet); +#endif + } else { + RSAKeySizeRand(paramInSet); + } +} + +void ParamForRSASign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramPadding[] = { + &g_PARAM_PADDING_PKCS1_V1_5, + &g_PARAM_PADDING_PSS, + }; + const uint32_t count = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramPadding[index], 1); + if (paramPadding[index]->uint32Param == HKS_PADDING_PKCS1_V1_5) { + ShaForPkcs1(paramInSet); + } else if (paramPadding[index]->uint32Param == HKS_PADDING_PSS) { + ShaForPss(paramInSet); + } +} + +void ParamForECCSign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_ECC_224, + &g_PARAM_KEYSIZE_ECC_256, + &g_PARAM_KEYSIZE_ECC_384, + &g_PARAM_KEYSIZE_ECC_521, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % countOfKeySize], 1); + + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1); +} + +void ParamForDSASign(struct HksParamSet *paramInSet) +{ + HksAddParams(paramInSet, &g_PARAM_PADDING_PKCS1_V1_5, 1); + HksAddParams(paramInSet, &g_PARAM_KEYSIZE_DSA_1024, 1); + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1); +} + +void ParamForSign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramAlgorithm[] = { + &g_PARAM_ALGORITHM_RSA, + &g_PARAM_ALGORITHM_ECC, +#ifndef _USE_MBEDTLS_ + &g_PARAM_ALGORITHM_DSA, +#endif + }; + const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramAlgorithm[index], 1); + if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) { + ParamForRSASign(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_ECC) { + ParamForECCSign(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_DSA) { + ParamForDSASign(paramInSet); + } +} + +void ParamForAgree(struct HksParamSet *generateKeyParam, struct HksParamSet *agreeKeyParam) +{ + const struct HksParam *paramAlg[] = { + &g_PARAM_ALGORITHM_ECDH, +#ifdef HKS_SUPPORT_DH_C + &g_PARAM_ALGORITHM_DH, +#endif + }; + const uint32_t countOfAlg = sizeof(paramAlg) / sizeof(struct HksParam *); + const uint32_t indexOfAlg = GetRandom() % countOfAlg; + + HksAddParams(agreeKeyParam, paramAlg[indexOfAlg], 1); + if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_ECDH) { + HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_ECC, 1); + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_ECC_224, + &g_PARAM_KEYSIZE_ECC_256, + &g_PARAM_KEYSIZE_ECC_384, + &g_PARAM_KEYSIZE_ECC_521, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + const uint32_t indexOfKeySize = GetRandom() % countOfKeySize; + HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(generateKeyParam, &g_PARAM_DIGEST_NONE, 1); + } +#ifdef HKS_SUPPORT_DH_C + if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_DH) { + HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_DH, 1); + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_DH_2048, + &g_PARAM_KEYSIZE_DH_3072, + &g_PARAM_KEYSIZE_DH_4096, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + const uint32_t indexOfKeySize = GetRandom() % countOfKeySize; + HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1); + } +#endif +} +} // namespace + +class ApiPressureTest : public testing::Test { +public: + void SetThreadState(bool threadState) + { + std::lock_guard lock(mutex_); + + threadState_ = threadState; + } + bool GetThreadState() + { + std::lock_guard lock(mutex_); + + return threadState_; + } + void GetSdkVersionTest(); + void InitializeTest(); + void RefreshKeyInfoTest(); + void GenerateKeyTest(); + void ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void DeleteKeyTest(uint32_t ii); + void GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void GenerateRandomTest(); + void SignTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message); + void VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message, + const struct HksBlob *signature); + void EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *cipherText, uint32_t *inLen); + void AgreeKeyTest(const struct HksBlob *authId); + void DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void HashTest(); + void CipherScene(uint32_t ii); + void SignScene(uint32_t ii); + void AgreeScene(uint32_t ii); + +private: + bool threadState_; + std::mutex mutex_; +}; + +void ApiPressureTest::GetSdkVersionTest() +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob sdkVersion = { .size = MAX_SDK_VERSION_SIZE, + .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE) }; + + EXPECT_EQ(HksGetSdkVersion(&sdkVersion), HKS_SUCCESS); + + HksFree(sdkVersion.data); + } while (1); +} + +void ApiPressureTest::InitializeTest() +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksInitialize(), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::RefreshKeyInfoTest() +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksRefreshKeyInfo(), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::GenerateKeyTest() +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(authId, paramInSet, &pubKey); + do { + if (!GetThreadState()) { + break; + } + struct HksBlob importId = { (uint32_t)strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY }; + EXPECT_EQ(HksImportKey(&importId, paramInSet, &pubKey), HKS_SUCCESS); + } while (1); + HksFree(pubKey.data); +} + +void ApiPressureTest::ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + EXPECT_EQ(HksExportPublicKey(authId, paramInSet, &pubKey), HKS_SUCCESS); + + HksFree(pubKey.data); + } while (1); +} + +void ApiPressureTest::DeleteKeyTest(uint32_t ii) +{ + do { + if (!GetThreadState()) { + break; + } + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + EXPECT_EQ(HksDeleteKey(&authId, paramInSet), HKS_SUCCESS); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksGetKeyParamSet(authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + } while (1); +} + +void ApiPressureTest::KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksKeyExist(authId, paramInSet), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::GenerateRandomTest() +{ + struct HksBlob authId = { .size = RANDOM_KEY_SIZE, .data = (uint8_t *)HksMalloc(RANDOM_KEY_SIZE) }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksGenerateRandom(paramInSet, &authId), HKS_SUCCESS); + } while (1); + HksFree(authId.data); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::SignTest( + const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + EXPECT_EQ(HksSign(authId, paramInSet, message, &signature), HKS_SUCCESS); + HksFree(signature.data); + } while (1); +} + +void ApiPressureTest::VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *message, const struct HksBlob *signature) +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksVerify(authId, paramInSet, message, signature), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + uint32_t inLen = dataLen + COMPLEMENT_LEN; + do { + if (!GetThreadState()) { + break; + } + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + EXPECT_EQ(HksEncrypt(authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + HksFree(cipherText.data); + } while (1); +} + +void ApiPressureTest::DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *cipherText, uint32_t *inLen) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob plainTextDecrypt = { .size = *inLen, .data = (uint8_t *)HksMalloc(*inLen) }; + EXPECT_EQ(HksDecrypt(authId, paramInSet, cipherText, &plainTextDecrypt), HKS_SUCCESS); + HksFree(plainTextDecrypt.data); + } while (1); +} + +void ApiPressureTest::AgreeKeyTest(const struct HksBlob *authId) +{ + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(authId, NULL, &pubKey); + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + do { + if (!GetThreadState()) { + break; + } + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + EXPECT_EQ(HksAgreeKey(paramInSet, authId, &pubKey, &agreeKey), HKS_SUCCESS); + HksFree(agreeKey.data); + } while (1); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob derivedKey = { .size = DERIVE_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVE_KEY_SIZE) }; + EXPECT_EQ(HksDeriveKey(paramInSet, authId, &derivedKey), HKS_SUCCESS); + HksFree(derivedKey.data); + } while (1); +} + +void ApiPressureTest::MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + do { + if (!GetThreadState()) { + break; + } + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + EXPECT_EQ(HksMac(authId, paramInSet, &message, &macMessage), HKS_SUCCESS); + HksFree(macMessage.data); + } while (1); +} + +void ApiPressureTest::HashTest() +{ + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; + HksAddParams(paramInSet, &digest, 1); + HksBuildParamSet(¶mInSet); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + do { + if (!GetThreadState()) { + break; + } + HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + EXPECT_EQ(HksHash(paramInSet, &message, &shaMessage), HKS_SUCCESS); + HksFree(shaMessage.data); + } while (1); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::CipherScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, CIPHER_PARAMS, sizeof(CIPHER_PARAMS) / sizeof(CIPHER_PARAMS[0])); + ParamForCipher(paramInSet); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + struct HksParam *padding = nullptr; + HksGetParam(paramInSet, HKS_TAG_PADDING, &padding); + char hexData[MAX_STRING_LENTH] = {0}; + uint32_t dataLen; + struct HksParam *algorithm = nullptr; + HksGetParam(paramInSet, HKS_TAG_ALGORITHM, &algorithm); + if (algorithm->uint32Param == HKS_ALG_RSA) { + if (padding->uint32Param == HKS_PADDING_NONE) { + struct HksParam *keySize = nullptr; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &keySize); + dataLen = HKS_KEY_BYTES(keySize->uint32Param); + } else { + dataLen = RSA_MESSAGE_SIZE; + } + } else { + dataLen = AES_MESSAGE_SIZE; + } + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob cipherText = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + HksBlob plainTextDecrypt = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); + HksFree(plainTextDecrypt.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::SignScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + ParamForSign(paramInSet); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + HksSign(&authId, paramInSet, &message, &signature); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::AgreeScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *generateKeyParam = nullptr; + HksInitParamSet(&generateKeyParam); + struct HksParamSet *agreeKeyParam = nullptr; + HksInitParamSet(&agreeKeyParam); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(generateKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksAddParams(agreeKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + ParamForAgree(generateKeyParam, agreeKeyParam); + HksBuildParamSet(&generateKeyParam); + HksBuildParamSet(&agreeKeyParam); + HksGenerateKey(&authId, generateKeyParam, NULL); + struct HksBlob pubKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + HksExportPublicKey(&authId, generateKeyParam, &pubKey); + HksBlob agreeKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + EXPECT_EQ(HksAgreeKey(agreeKeyParam, &authId, &pubKey, &agreeKey), HKS_SUCCESS); + HksFree(agreeKey.data); + HksFree(pubKey.data); + HksFreeParamSet(&generateKeyParam); + HksFreeParamSet(&agreeKeyParam); + } while (1); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00100 + * @tc.name : ApiPressureTest00100 + * @tc.desc : HksGetSdkVersion + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00100, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GetSdkVersionTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00200 + * @tc.name : ApiPressureTest00200 + * @tc.desc : HksInitialize + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00200, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::InitializeTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00300 + * @tc.name : ApiPressureTest00300 + * @tc.desc : HksRefreshKeyInfo + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00300, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::RefreshKeyInfoTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00400 + * @tc.name : ApiPressureTest00400 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00400, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GenerateKeyTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00500 + * @tc.name : ApiPressureTest00500 + * @tc.desc : HksImportKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00500, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::ImportKeyTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00600 + * @tc.name : ApiPressureTest00600 + * @tc.desc : HksExportPublicKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00600, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::ExportPublicKeyTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00700 + * @tc.name : ApiPressureTest00700 + * @tc.desc : HksDeleteKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00700, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::DeleteKeyTest, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00800 + * @tc.name : ApiPressureTest00800 + * @tc.desc : HksGetKeyParamSet + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00800, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GetKeyParamSetTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00900 + * @tc.name : ApiPressureTest00900 + * @tc.desc : HksKeyExist + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00900, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::KeyExistTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01000 + * @tc.name : ApiPressureTest01000 + * @tc.desc : HksGenerateRandom + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01000, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GenerateRandomTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01100 + * @tc.name : ApiPressureTest01100 + * @tc.desc : HksSign + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01100, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::SignTest, this, &authId, paramInSet, &message)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01200 + * @tc.name : ApiPressureTest01200 + * @tc.desc : HksVerify + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01200, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksSign(&authId, paramInSet, &message, &signature); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back( + std::thread(&ApiPressureTest::VerifyTest, this, &authId, paramInSet, &message, &signature)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFree(signature.data); + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01300 + * @tc.name : ApiPressureTest01300 + * @tc.desc : HksEncrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01300, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::EncryptTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01400 + * @tc.name : ApiPressureTest01400 + * @tc.desc : HksDecrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01400, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back( + std::thread(&ApiPressureTest::DecryptTest, this, &authId, paramInSet, &cipherText, &inLen)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01500 + * @tc.name : ApiPressureTest01500 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01500, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::AgreeKeyTest, this, &authId)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01600 + * @tc.name : ApiPressureTest01600 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01600, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + struct HksParamSet *paramInSetHkdf = nullptr; + HksInitParamSet(¶mInSetHkdf); + struct HksParam tmpParamsHkdf[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0])); + HksBuildParamSet(¶mInSetHkdf); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::DeriveKeyTest, this, &authId, paramInSetHkdf)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mInSetHkdf); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01700 + * @tc.name : ApiPressureTest01700 + * @tc.desc : HksMac + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01700, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::MacTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01800 + * @tc.name : ApiPressureTest01800 + * @tc.desc : HksHash + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01800, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::HashTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01900 + * @tc.name : ApiPressureTest01900 + * @tc.desc : Scenario 1: generate key and encrypt / decrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01900, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::CipherScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest02000 + * @tc.name : ApiPressureTest02000 + * @tc.desc : Scenario 2: generate key and sign / verify + */ +HWTEST_F(ApiPressureTest, ApiPressureTest02000, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::SignScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest02100 + * @tc.name : ApiPressureTest02100 + * @tc.desc : Scenario 3: generate key and agree + */ +HWTEST_F(ApiPressureTest, ApiPressureTest02100, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::AgreeScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} +} // namespace \ No newline at end of file diff --git a/test/stability/src/pressure_test.cpp b/test/stability/src/pressure_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..286e4b65d7c11581974004a177084272e81c22a1 --- /dev/null +++ b/test/stability/src/pressure_test.cpp @@ -0,0 +1,1263 @@ +/* + * Copyright (C) 2021 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 + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char GENERATE_KEY[] = "This is for generate key"; +const char IMPORT_KEY[] = "This is for import key"; +const uint32_t TEST_FREQUENCY = 1000; +const uint32_t MAX_SDK_VERSION_SIZE = 64; +const uint32_t IV_SIZE = 16; +const uint32_t COMPLEMENT_LEN = 16; +const uint32_t KEY_PARAMSET_SIZE = 1024; +const uint32_t MESSAGE_SIZE = 64; +const uint32_t TEST_KEY_SIZE = 512; +const uint32_t DERIVED_KEY_SIZE = 64; + +static const struct HksParam PARAMS_FOR_ENCRYPT[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, +}; + +static const struct HksParam PARAMS_FOR_DECRYPT[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, +}; +} // namespace +class PressureTest : public testing::Test { +public: + int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, + struct HksBlob *priKey, struct HksBlob *pubKey); +}; + +int32_t PressureTest::LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, + const struct HksParamSet *paramSetIn, struct HksBlob *priKey, struct HksBlob *pubKey) +{ + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { + return HKS_SUCCESS; + } + + HksParam *priParam = nullptr; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + priKey->size = priParam->blob.size; + (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = nullptr; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + pubKey->size = pubParam->blob.size; + (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + return HKS_SUCCESS; +} + +/** + * @tc.number : PressureTest.PressureTest00100 + * @tc.name : PressureTest00100 + * @tc.desc : HksGetSdkVersion + */ +HWTEST_F(PressureTest, PressureTest00100, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob sdkVersion = { .size = MAX_SDK_VERSION_SIZE, + .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGetSdkVersion(&sdkVersion); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + HksFree(sdkVersion.data); + } + HKS_LOG_I("HksGetSdkVersion Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00200 + * @tc.name : PressureTest00200 + * @tc.desc : HksInitialize + */ +HWTEST_F(PressureTest, PressureTest00200, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksInitialize(); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HKS_LOG_I("HksInitialize Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00300 + * @tc.name : PressureTest00300 + * @tc.desc : HksRefreshKeyInfo + */ +HWTEST_F(PressureTest, PressureTest00300, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksRefreshKeyInfo(); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HKS_LOG_I("HksRefreshKeyInfo Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00400 + * @tc.name : PressureTest00400 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(PressureTest, PressureTest00400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateKey(&authId, paramInSet, NULL); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksGenerateKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00500 + * @tc.name : PressureTest00500 + * @tc.desc : HksImportKey + */ +HWTEST_F(PressureTest, PressureTest00500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(&authId, paramInSet, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob importId = { strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksImportKey(&importId, paramInSet, &pubKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + HksDeleteKey(&importId, paramInSet); + } + HksDeleteKey(&authId, paramInSet); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksImportKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00600 + * @tc.name : PressureTest00600 + * @tc.desc : HksExportPublicKey + */ +HWTEST_F(PressureTest, PressureTest00600, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksExportPublicKey(&authId, paramInSet, &pubKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(pubKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksExportPublicKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00700 + * @tc.name : PressureTest00700 + * @tc.desc : HksDeleteKey + */ +HWTEST_F(PressureTest, PressureTest00700, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeleteKey(&authId, paramInSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksDeleteKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00800 + * @tc.name : PressureTest00800 + * @tc.desc : HksGetKeyParamSet + */ +HWTEST_F(PressureTest, PressureTest00800, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGetKeyParamSet(&authId, paramInSet, paramOutSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksGetKeyParamSet Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00900 + * @tc.name : PressureTest00900 + * @tc.desc : HksKeyExist + */ +HWTEST_F(PressureTest, PressureTest00900, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksKeyExist(&authId, paramInSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksKeyExist Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01000 + * @tc.name : PressureTest01000 + * @tc.desc : HksGenerateRandom + */ +HWTEST_F(PressureTest, PressureTest01000, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateRandom(paramInSet, &authId); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksGenerateRandom Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01100 + * @tc.name : PressureTest01100 + * @tc.desc : HksSign + */ +HWTEST_F(PressureTest, PressureTest01100, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksSign(&authId, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(signature.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksSign Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01200 + * @tc.name : PressureTest01200 + * @tc.desc : HksVerify + */ +HWTEST_F(PressureTest, PressureTest01200, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + HksSign(&authId, paramInSet, &message, &signature); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksVerify(&authId, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksDeleteKey(&authId, paramInSet); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksVerify Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01300 + * @tc.name : PressureTest01300 + * @tc.desc : HksEncrypt + */ +HWTEST_F(PressureTest, PressureTest01300, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(cipherText.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksEncrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01400 + * @tc.name : PressureTest01400 + * @tc.desc : HksDecrypt + */ +HWTEST_F(PressureTest, PressureTest01400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(plainTextDecrypt.data); + } + HksDeleteKey(&authId, paramInSet); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksDecrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01500 + * @tc.name : PressureTest01500 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(PressureTest, PressureTest01500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(&authId, paramInSet, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksAgreeKey(paramInSet, &authId, &pubKey, &agreeKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(agreeKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksAgreeKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01600 + * @tc.name : PressureTest01600 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(PressureTest, PressureTest01600, TestSize.Level1) +{ + double programTimes = 0; + + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksParamSet *paramInSetHkdf = nullptr; + HksInitParamSet(¶mInSetHkdf); + struct HksParam tmpParamsHkdf[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0])); + HksBuildParamSet(¶mInSetHkdf); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeriveKey(paramInSetHkdf, &authId, &derivedKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(derivedKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mInSetHkdf); + HKS_LOG_I("HksDeriveKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01700 + * @tc.name : PressureTest01700 + * @tc.desc : HksMac + */ +HWTEST_F(PressureTest, PressureTest01700, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksMac(&authId, paramInSet, &message, &macMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(macMessage.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksMac Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01800 + * @tc.name : PressureTest01800 + * @tc.desc : HksHash + */ +HWTEST_F(PressureTest, PressureTest01800, TestSize.Level1) +{ + double programTimes = 0; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; + HksAddParams(paramInSet, &digest, 1); + HksBuildParamSet(¶mInSet); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksHash(paramInSet, &message, &shaMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(shaMessage.data); + } + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksHash Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01900 + * @tc.name : PressureTest01900 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(PressureTest, PressureTest01900, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateKey(&authId, paramInSet, paramOutSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + } + HKS_LOG_I("Local HksGenerateKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02000 + * @tc.name : PressureTest02000 + * @tc.desc : HksSign + */ +HWTEST_F(PressureTest, PressureTest02000, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksSign(&priKey, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(signature.data); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksSign Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02100 + * @tc.name : PressureTest02100 + * @tc.desc : HksVerify + */ +HWTEST_F(PressureTest, PressureTest02100, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + HksSign(&priKey, paramInSet, &message, &signature); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksVerify(&pubKey, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksVerify Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02200 + * @tc.name : PressureTest02200 + * @tc.desc : HksEncrypt + */ +HWTEST_F(PressureTest, PressureTest02200, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, PARAMS_FOR_ENCRYPT, sizeof(PARAMS_FOR_ENCRYPT) / sizeof(PARAMS_FOR_ENCRYPT[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksEncrypt(&authKey, paramInSet, &plainText, &cipherText); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(cipherText.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksEncrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02300 + * @tc.name : PressureTest02300 + * @tc.desc : HksDecrypt + */ +HWTEST_F(PressureTest, PressureTest02300, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, PARAMS_FOR_DECRYPT, sizeof(PARAMS_FOR_DECRYPT) / sizeof(PARAMS_FOR_DECRYPT[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + HksEncrypt(&authKey, paramInSet, &plainText, &cipherText); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDecrypt(&authKey, paramInSet, &cipherText, &plainTextDecrypt); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(plainTextDecrypt.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksDecrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02400 + * @tc.name : PressureTest02400 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(PressureTest, PressureTest02400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksAgreeKey(paramInSet, &priKey, &pubKey, &agreeKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(agreeKey.data); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksAgreeKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02500 + * @tc.name : PressureTest02500 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(PressureTest, PressureTest02500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateRandom(paramInSet, &authId); + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeriveKey(paramInSet, &authId, &derivedKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(derivedKey.data); + } + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksDeriveKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02600 + * @tc.name : PressureTest02600 + * @tc.desc : HksMac + */ +HWTEST_F(PressureTest, PressureTest02600, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksMac(&authKey, paramInSet, &message, &macMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(macMessage.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksMac Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} +} // namespace \ No newline at end of file diff --git a/test/unittest/src/common/hks_test_aes.c b/test/unittest/src/common/hks_test_aes.c index 905c00eabb0302a34644907e09307a9d91d54df3..e0ecebda0ba5a5077e59aba722a7e784524b8372 100644 --- a/test/unittest/src/common/hks_test_aes.c +++ b/test/unittest/src/common/hks_test_aes.c @@ -579,6 +579,7 @@ int32_t TestAes256ByLocal() struct HksBlob plainText = { TEST_AES_256, tmp }; ret = HksDecrypt(&keyBlob, paramSet, &cipherText, &plainText); HKS_TEST_ASSERT(ret == 0); + HKS_TEST_ASSERT(plainText1.size == plainText.size); HKS_TEST_ASSERT(memcmp(plainText.data, plainText1.data, plainText.size) == 0); HksFreeParamSet(¶mSet); diff --git a/test/unittest/src/liteos_a_adapter/BUILD.gn b/test/unittest/src/liteos_a_adapter/BUILD.gn index 85a2e076174246c4840335f425c4583ebf051903..6ffa9c08aaf9701eb8dba8f2fb70a13224f169ae 100644 --- a/test/unittest/src/liteos_a_adapter/BUILD.gn +++ b/test/unittest/src/liteos_a_adapter/BUILD.gn @@ -41,6 +41,7 @@ unittest("huks_3.0_test") { include_dirs = [ "//base/security/huks/interfaces/innerkits/huks_lite", + "//base/security/huks/huawei_property/include", "../common/include", ] diff --git a/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp b/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp index 4dcc6d884c2b7473956cd5c44567996e10b49f8e..dfd9fe45e1e75652064ca8a013c0fda40078443a 100644 --- a/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp @@ -57,7 +57,7 @@ void HksAesTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree() == 0); } @@ -67,7 +67,7 @@ HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree1() == 0); } @@ -77,7 +77,7 @@ HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree2() == 0); } @@ -88,7 +88,7 @@ HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest004, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest004, TestSize.Level0) { ASSERT_EQ(TestAes256ByLocal(), 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp b/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp index 14460dc1caf5a57c4490faa65b08c36341bab9f5..914fe48d2e04c9bd646901a2c2b40838b3455200 100644 --- a/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp @@ -98,7 +98,7 @@ static int32_t AgreeKey(const struct HksTestAgreeParamSet *agreeParamSetParams, * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; @@ -147,7 +147,7 @@ HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest002, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest002, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp b/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp index fa182c31769573dec7864b826eeb75aa539ec5ff..e818517bef0bd825c816bb65b2628c4e8bcbd741 100644 --- a/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp @@ -96,7 +96,7 @@ static int32_t TestValue() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level1) +HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level0) { int32_t ret; if (g_testBnExpModParams[0].isTestValue) { diff --git a/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp b/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp index 22de5c8e6eff1ce40a3fcdba29b13f37bf5fa610..bc8816eacab40c3b732f6af461578e4105072a51 100644 --- a/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp @@ -56,63 +56,63 @@ void HksCipherTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 0, 1) == 0); } #ifndef _CUT_AUTHENTICATE_ -HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 4, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 4, 1) == 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp b/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp index 13bd2c35fdd108c9ddea4982164144630770bfb8..e2d1427240f602cb6358ccfb0811793d25351be9 100644 --- a/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp @@ -57,7 +57,7 @@ void HksCurve25519Test::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level0) { ASSERT_TRUE(TestCurve25519All() == 0); } @@ -67,7 +67,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level0) { ASSERT_TRUE(TestEd25519SignTeeVerifyLocal() == 0); } @@ -77,7 +77,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level0) { ASSERT_TRUE(TestCurve25519SignWrong() == 0); } @@ -87,7 +87,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level0) { ASSERT_TRUE(TestCurve25519verifyWrong() == 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp b/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp index db5c83415324679d9d7245590f7ae9f6efbfda1c..a3c3b33987401bc8776d549616e99f95e4c161c1 100644 --- a/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp @@ -65,7 +65,7 @@ const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level1) +HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp b/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp index 2f0f33a8fabec402ea5825e4b2457ddade5395ce..7532c8999eb9add377bc946b9eb64ba343900bcb 100644 --- a/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp @@ -203,7 +203,7 @@ static int32_t BaseTestDerive(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level0) { int32_t ret = BaseTestDerive(0); ASSERT_TRUE(ret == 0); @@ -215,7 +215,7 @@ HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level0) { int32_t ret = BaseTestDerive(1); ASSERT_TRUE(ret == 0); diff --git a/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp b/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp index d347851e78c93e106004b7c174e2987e17d432ae..a993a447def42b738bf56b25a02ae11ef14ca47f 100644 --- a/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp @@ -65,7 +65,7 @@ const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level1) +HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp index 43894c0e3b5bbe1bc83290dd21b388f7d10642e0..16238f3053b9249dd7b7615d8d38bf844c2385fe 100644 --- a/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp @@ -76,7 +76,7 @@ const struct HksTestGenKeyParams g_testGenKeyParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level1) +HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level0) { uint32_t times = 1; uint32_t index = 0; diff --git a/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp b/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp index f5ad2e91ee01764a2c6e29f06ecbde6787c8c362..80f716c1e82965556edbf13815d366fc1c7ee013 100644 --- a/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp @@ -63,7 +63,7 @@ const struct HksTestGenRandomParams g_testGenRandomParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level1) +HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level0) { int32_t ret; struct HksBlob *random = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp b/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp index 4e4575130ac005bf875e0232993cf7b6e802e356..67abaa03e7419532309835b61605ca401f338b40 100644 --- a/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp @@ -73,7 +73,7 @@ const struct HksTestHashParams g_testHashParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level1) +HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level0) { struct HksParamSet *paramSet = NULL; struct HksBlob *srcData = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp b/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp index f590c65cb7db5e7c54fe1528f76feae11483bc49..593a79704d4418f493eff9df8af5553858e6dea6 100644 --- a/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp @@ -182,7 +182,7 @@ static int32_t BaseTestMac(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level0) { int32_t ret = BaseTestMac(0); ASSERT_TRUE(ret == 0); @@ -194,7 +194,7 @@ HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level0) { int32_t ret = BaseTestMac(1); ASSERT_TRUE(ret == 0); diff --git a/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp index 2b09995458a65273153e54719cb1b3ab1805b17a..51ef5b994bab886295962eb59949b1da5e7add01 100644 --- a/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp @@ -307,7 +307,7 @@ int32_t BaseTestCipherProcess(struct HksBlob *keyAlias, uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level1) +HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level0) { uint32_t index = 0; struct HksBlob keyAlias = { strlen(g_testName), (uint8_t *)g_testName }; diff --git a/test/unittest/src/liteos_a_adapter/hks_others_test.cpp b/test/unittest/src/liteos_a_adapter/hks_others_test.cpp index 359c21681029e888557bf19c04d5586fad15caa7..8449fc6a5c57788fc2da0a9ff117750d4daccc97 100644 --- a/test/unittest/src/liteos_a_adapter/hks_others_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_others_test.cpp @@ -57,7 +57,7 @@ void HksOthersTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level0) { int32_t ret = HksGetKeyParamSet(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -68,7 +68,7 @@ HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level0) { int32_t ret = HksGetKeyInfoList(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -79,7 +79,7 @@ HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level0) { int32_t ret = HksAttestKey(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -90,7 +90,7 @@ HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level0) { int32_t ret = HksGetCertificateChain(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -101,7 +101,7 @@ HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level0) { int32_t ret = HksWrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -112,7 +112,7 @@ HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level0) { int32_t ret = HksUnwrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -123,7 +123,7 @@ HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level0) { int32_t ret = HksGetSdkVersion(NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -134,7 +134,7 @@ HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level0) { int32_t ret = HksInitialize(); ASSERT_TRUE(ret == HKS_SUCCESS); diff --git a/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp index b670ac89ee9c57515aa179d44a0e9efec230f5ec..d10edc117b688eeb759eda52398adfe12445b5a4 100644 --- a/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp @@ -84,7 +84,7 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level0) { struct HksBlob ed25519Alias = { strlen(g_testEd25519), (uint8_t *)g_testEd25519 }; int32_t ret = TestGenerateEd25519Key(ed25519Alias); diff --git a/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp index b03096058ace43b8cdd07afa5f2269fa381a6d49..7ff0129cb5dde2e3ee49756b74ab9502ad76a8ac 100644 --- a/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp @@ -147,7 +147,7 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level0) { struct HksBlob keyAliasOne = { strlen(g_testOne), (uint8_t *)g_testOne }; int32_t ret = SafeTestGenerateKey(&keyAliasOne); diff --git a/test/unittest/src/liteos_m_adapter/BUILD.gn b/test/unittest/src/liteos_m_adapter/BUILD.gn index 0d2414b1b64c5abdf825d1e7af0371402a14a4ab..73eeeb4d94cf49dc57cd72037624a69bb51defec 100644 --- a/test/unittest/src/liteos_m_adapter/BUILD.gn +++ b/test/unittest/src/liteos_m_adapter/BUILD.gn @@ -38,6 +38,7 @@ hctest_suite("huks_3.0_test") { ] include_dirs = [ "//base/security/huks/interfaces/innerkits/huks_lite", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", "../common/include", ]