From a122fae2669ae2bc92ea727551673e131abe345e Mon Sep 17 00:00:00 2001 From: Juliusz Sosinowicz Date: Fri, 26 Jul 2024 13:49:53 +0200 Subject: [PATCH] Add softhsm patch Depends on https://github.com/wolfSSL/wolfssl/pull/7797 --- softhsm/2.6.1.patch | 2114 +++++++++++++++++++++++++++++++++++++++++++ softhsm/README | 6 + 2 files changed, 2120 insertions(+) create mode 100644 softhsm/2.6.1.patch create mode 100644 softhsm/README diff --git a/softhsm/2.6.1.patch b/softhsm/2.6.1.patch new file mode 100644 index 00000000..7ca1cefd --- /dev/null +++ b/softhsm/2.6.1.patch @@ -0,0 +1,2114 @@ +From 408648090c66c32c66fe1ca6298ae08ef8f14c42 Mon Sep 17 00:00:00 2001 +From: Juliusz Sosinowicz +Date: Fri, 14 Jun 2024 17:45:19 +0200 +Subject: [PATCH] Patch for wolfSSL support + +This patch implements wolfSSL support in SoftHSMv2. + +Compile wolfSSL with: + ./configure --enable-all + make + make install + +Compile SoftHSMv2 with: + patch -p1 < /path/to/this/patch + autoreconf -if + ./configure --with-crypto-backend=wolfssl + make + +To run the tests: + make check + +When building for FIPS or with wolfSSL releases 5.7.2 and older add `CPPFLAGS=-DRSA_LOW_MEM` to the wolfSSL configuration: + ./configure --enable-all CPPFLAGS=-DRSA_LOW_MEM +--- + m4/acx_crypto_backend.m4 | 40 +++++++- + src/bin/keyconv/softhsm2-keyconv-ossl.cpp | 25 ++++- + src/bin/util/softhsm2-util-ossl.cpp | 6 ++ + src/lib/P11Attributes.cpp | 2 +- + src/lib/SoftHSM.cpp | 68 ++++++------- + src/lib/crypto/AsymmetricAlgorithm.h | 2 +- + src/lib/crypto/BotanCryptoFactory.cpp | 16 +-- + src/lib/crypto/BotanCryptoFactory.h | 2 +- + src/lib/crypto/BotanRSA.cpp | 30 +++--- + src/lib/crypto/CryptoFactory.h | 2 +- + src/lib/crypto/HashAlgorithm.h | 18 ++-- + src/lib/crypto/OSSLCMAC.cpp | 2 + + src/lib/crypto/OSSLCryptoFactory.cpp | 22 ++-- + src/lib/crypto/OSSLCryptoFactory.h | 4 +- + src/lib/crypto/OSSLDES.cpp | 6 ++ + src/lib/crypto/OSSLDHPrivateKey.cpp | 2 + + src/lib/crypto/OSSLDHPublicKey.cpp | 2 + + src/lib/crypto/OSSLDSA.cpp | 26 ++--- + src/lib/crypto/OSSLDSAPrivateKey.cpp | 2 + + src/lib/crypto/OSSLDSAPublicKey.cpp | 2 + + src/lib/crypto/OSSLECPrivateKey.cpp | 4 + + src/lib/crypto/OSSLRSA.cpp | 116 ++++++++++++---------- + src/lib/crypto/OSSLRSAPrivateKey.cpp | 2 + + src/lib/crypto/OSSLRSAPublicKey.cpp | 2 + + src/lib/crypto/SymmetricKey.cpp | 2 +- + src/lib/crypto/test/AESTests.cpp | 12 +++ + src/lib/crypto/test/DESTests.cpp | 34 +++++++ + src/lib/crypto/test/DESTests.h | 2 + + src/lib/crypto/test/DHTests.cpp | 5 + + src/lib/crypto/test/DSATests.cpp | 4 + + src/lib/crypto/test/ECDSATests.cpp | 14 +-- + src/lib/crypto/test/GOSTTests.cpp | 4 +- + src/lib/crypto/test/HashTests.cpp | 12 +-- + src/lib/crypto/test/MacTests.cpp | 2 + + src/lib/crypto/test/MacTests.h | 4 + + src/lib/crypto/test/RSATests.cpp | 14 +-- + src/lib/data_mgr/RFC4880.cpp | 2 +- + src/lib/session_mgr/Session.cpp | 8 +- + src/lib/session_mgr/Session.h | 6 +- + 39 files changed, 352 insertions(+), 176 deletions(-) + +diff --git a/m4/acx_crypto_backend.m4 b/m4/acx_crypto_backend.m4 +index 8eefd66..a7a3c8d 100644 +--- a/m4/acx_crypto_backend.m4 ++++ b/m4/acx_crypto_backend.m4 +@@ -53,7 +53,7 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ + + AC_ARG_WITH(crypto-backend, + AC_HELP_STRING([--with-crypto-backend], +- [Select crypto backend (openssl|botan)] ++ [Select crypto backend (openssl|botan|wolfssl)] + ), + [crypto_backend="${withval}"], + [crypto_backend="openssl"] +@@ -161,6 +161,42 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ + [Compile with Botan support] + ) + ++ elif test "x${crypto_backend}" = "xwolfssl"; then ++ AC_MSG_RESULT(wolfSSL) ++ ++ AS_IF([test -z $WOLFSSL_INSTALL_DIR || test ! -d $WOLFSSL_INSTALL_DIR ], [ ++ WOLFSSL_INSTALL_DIR=/usr/local ++ ]) ++ ++ CRYPTO_INCLUDES="-I$WOLFSSL_INSTALL_DIR/include -I$WOLFSSL_INSTALL_DIR/include/wolfssl" ++ CRYPTO_LIBS="-lwolfssl -L$WOLFSSL_INSTALL_DIR/lib" ++ ++ acx_cv_lib_openssl_sufficient=yes ++ enable_ecc=yes ++ enable_eddsa=no ++ enable_gost=no ++ enable_fips=no ++ ++ AC_DEFINE_UNQUOTED( ++ [WITH_RAW_PSS], ++ [1], ++ [Compile with raw RSA PKCS PSS] ++ ) ++ AC_DEFINE_UNQUOTED( ++ [WITH_OPENSSL], ++ [], ++ [Compile with OpenSSL support] ++ ) ++ AC_DEFINE_UNQUOTED( ++ [WITH_WOLFSSL], ++ [], ++ [Compile with wolfssl support] ++ ) ++ AC_DEFINE_UNQUOTED( ++ [EXTERNAL_OPTS_OPENVPN], ++ [], ++ [wolfoptions] ++ ) + else + AC_MSG_RESULT(Unknown) + AC_MSG_ERROR([Crypto backend ${crypto_backend} not supported. Use openssl or botan.]) +@@ -208,7 +244,7 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ + + AC_SUBST(CRYPTO_INCLUDES) + AC_SUBST(CRYPTO_LIBS) +- AM_CONDITIONAL([WITH_OPENSSL], [test "x${crypto_backend}" = "xopenssl"]) ++ AM_CONDITIONAL([WITH_OPENSSL], [test "x${crypto_backend}" = "xopenssl" || test "x${crypto_backend}" = "xwolfssl"]) + AM_CONDITIONAL([WITH_BOTAN], [test "x${crypto_backend}" = "xbotan"]) + + ]) +diff --git a/src/bin/keyconv/softhsm2-keyconv-ossl.cpp b/src/bin/keyconv/softhsm2-keyconv-ossl.cpp +index a5cd8eb..7df3b61 100644 +--- a/src/bin/keyconv/softhsm2-keyconv-ossl.cpp ++++ b/src/bin/keyconv/softhsm2-keyconv-ossl.cpp +@@ -75,7 +75,9 @@ int save_rsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + EVP_PKEY* ossl_pkey = NULL; + PKCS8_PRIV_KEY_INFO* p8inf = NULL; + BIO* out = NULL; ++#ifndef WITH_WOLFSSL + X509_SIG* p8 = NULL; ++#endif + int result = 0; + + // See if the key material was found. +@@ -127,7 +129,6 @@ int save_rsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + EVP_PKEY_free(ossl_pkey); + return 1; + } +- EVP_PKEY_free(ossl_pkey); + + // Open output file + if (!(out = BIO_new_file (out_path, "wb"))) +@@ -145,6 +146,7 @@ int save_rsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + } + else + { ++#ifndef WITH_WOLFSSL + // Encrypt p8 + if (!(p8 = PKCS8_encrypt(NID_pbeWithMD5AndDES_CBC, NULL, + file_pin, strlen(file_pin), NULL, +@@ -159,6 +161,15 @@ int save_rsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + X509_SIG_free(p8); + printf("The key has been written to %s\n", out_path); + } ++#else ++ if (wolfSSL_PEM_write_bio_PKCS8PrivateKey( ++ out, ossl_pkey, wolfSSL_EVP_aes_256_cbc(), file_pin, ++ strlen(file_pin), NULL, NULL) == 0) ++ { ++ fprintf(stderr, "ERROR: wolfSSL_PEM_write_bio_PKCS8PrivateKey failed\n"); ++ result = 1; ++ } ++#endif + } + + PKCS8_PRIV_KEY_INFO_free(p8inf); +@@ -174,7 +185,9 @@ int save_dsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + EVP_PKEY* ossl_pkey = NULL; + PKCS8_PRIV_KEY_INFO* p8inf = NULL; + BIO* out = NULL; ++#ifndef WITH_WOLFSSL + X509_SIG* p8 = NULL; ++#endif + int result = 0; + + // See if the key material was found. +@@ -238,6 +251,7 @@ int save_dsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + } + else + { ++#ifndef WITH_WOLFSSL + // Encrypt p8 + if (!(p8 = PKCS8_encrypt(NID_pbeWithMD5AndDES_CBC, NULL, + file_pin, strlen(file_pin), NULL, +@@ -252,6 +266,15 @@ int save_dsa_pkcs8(char* out_path, char* file_pin, key_material_t* pkey) + X509_SIG_free(p8); + printf("The key has been written to %s\n", out_path); + } ++#else ++ if (wolfSSL_PEM_write_bio_PKCS8PrivateKey( ++ out, ossl_pkey, wolfSSL_EVP_aes_256_cbc(), file_pin, ++ strlen(file_pin), NULL, NULL) == 0) ++ { ++ fprintf(stderr, "ERROR: wolfSSL_PEM_write_bio_PKCS8PrivateKey failed\n"); ++ result = 1; ++ } ++#endif + } + + PKCS8_PRIV_KEY_INFO_free(p8inf); +diff --git a/src/bin/util/softhsm2-util-ossl.cpp b/src/bin/util/softhsm2-util-ossl.cpp +index 83c6ac1..c512fac 100644 +--- a/src/bin/util/softhsm2-util-ossl.cpp ++++ b/src/bin/util/softhsm2-util-ossl.cpp +@@ -222,7 +222,9 @@ EVP_PKEY* crypto_read_file(char* filePath, char* filePIN) + BIO* in = NULL; + PKCS8_PRIV_KEY_INFO* p8inf = NULL; + EVP_PKEY* pkey = NULL; ++#ifndef WITH_WOLFSSL + X509_SIG* p8 = NULL; ++#endif + + if (!(in = BIO_new_file(filePath, "rb"))) + { +@@ -233,6 +235,7 @@ EVP_PKEY* crypto_read_file(char* filePath, char* filePIN) + // The PKCS#8 file is encrypted + if (filePIN) + { ++#ifndef WITH_WOLFSSL + p8 = PEM_read_bio_PKCS8(in, NULL, NULL, NULL); + BIO_free(in); + +@@ -252,6 +255,9 @@ EVP_PKEY* crypto_read_file(char* filePath, char* filePIN) + "Maybe wrong PIN to file (--file-pin )\n"); + return NULL; + } ++#else ++ p8inf = (EVP_PKEY*)wolfSSL_PEM_read_bio_PrivateKey(in, NULL, NULL, filePIN); ++#endif + } + else + { +diff --git a/src/lib/P11Attributes.cpp b/src/lib/P11Attributes.cpp +index bfcf445..9fba44a 100644 +--- a/src/lib/P11Attributes.cpp ++++ b/src/lib/P11Attributes.cpp +@@ -978,7 +978,7 @@ CK_RV P11AttrValue::updateAttr(Token *token, bool isPrivate, CK_VOID_PTR pValue, + // Calculate the CKA_CHECK_VALUE for certificates + if (osobject->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) == CKO_CERTIFICATE) + { +- HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA1); ++ HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA1); + if (hash == NULL) return CKR_GENERAL_ERROR; + + ByteString digest; +diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp +index 0a0c32c..6935dcd 100644 +--- a/src/lib/SoftHSM.cpp ++++ b/src/lib/SoftHSM.cpp +@@ -3557,31 +3557,31 @@ CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + + // Get the mechanism +- HashAlgo::Type algo = HashAlgo::Unknown; ++ HashAlgo::shsm_Type algo = HashAlgo::shsm_Unknown; + switch(pMechanism->mechanism) { + #ifndef WITH_FIPS + case CKM_MD5: +- algo = HashAlgo::MD5; ++ algo = HashAlgo::shsm_MD5; + break; + #endif + case CKM_SHA_1: +- algo = HashAlgo::SHA1; ++ algo = HashAlgo::shsm_SHA1; + break; + case CKM_SHA224: +- algo = HashAlgo::SHA224; ++ algo = HashAlgo::shsm_SHA224; + break; + case CKM_SHA256: +- algo = HashAlgo::SHA256; ++ algo = HashAlgo::shsm_SHA256; + break; + case CKM_SHA384: +- algo = HashAlgo::SHA384; ++ algo = HashAlgo::shsm_SHA384; + break; + case CKM_SHA512: +- algo = HashAlgo::SHA512; ++ algo = HashAlgo::shsm_SHA512; + break; + #ifdef WITH_GOST + case CKM_GOSTR3411: +- algo = HashAlgo::GOST; ++ algo = HashAlgo::shsm_GOST; + break; + #endif + default: +@@ -3730,12 +3730,12 @@ CK_RV SoftHSM::C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) + } + + // Whitelist +- HashAlgo::Type algo = session->getHashAlgo(); +- if (algo != HashAlgo::SHA1 && +- algo != HashAlgo::SHA224 && +- algo != HashAlgo::SHA256 && +- algo != HashAlgo::SHA384 && +- algo != HashAlgo::SHA512) ++ HashAlgo::shsm_Type algo = session->getHashAlgo(); ++ if (algo != HashAlgo::shsm_SHA1 && ++ algo != HashAlgo::shsm_SHA224 && ++ algo != HashAlgo::shsm_SHA256 && ++ algo != HashAlgo::shsm_SHA384 && ++ algo != HashAlgo::shsm_SHA512) + { + // Parano... + if (!key->getBooleanValue(CKA_EXTRACTABLE, false)) +@@ -4108,27 +4108,27 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + + switch(CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) { + case CKM_SHA_1: +- pssParam.hashAlg = HashAlgo::SHA1; ++ pssParam.hashAlg = HashAlgo::shsm_SHA1; + pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + allowedMgf = CKG_MGF1_SHA1; + break; + case CKM_SHA224: +- pssParam.hashAlg = HashAlgo::SHA224; ++ pssParam.hashAlg = HashAlgo::shsm_SHA224; + pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + allowedMgf = CKG_MGF1_SHA224; + break; + case CKM_SHA256: +- pssParam.hashAlg = HashAlgo::SHA256; ++ pssParam.hashAlg = HashAlgo::shsm_SHA256; + pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + allowedMgf = CKG_MGF1_SHA256; + break; + case CKM_SHA384: +- pssParam.hashAlg = HashAlgo::SHA384; ++ pssParam.hashAlg = HashAlgo::shsm_SHA384; + pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + allowedMgf = CKG_MGF1_SHA384; + break; + case CKM_SHA512: +- pssParam.hashAlg = HashAlgo::SHA512; ++ pssParam.hashAlg = HashAlgo::shsm_SHA512; + pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + allowedMgf = CKG_MGF1_SHA512; + break; +@@ -4159,7 +4159,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA1_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA1; ++ pssParam.hashAlg = HashAlgo::shsm_SHA1; + pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -4177,7 +4177,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA224_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA224; ++ pssParam.hashAlg = HashAlgo::shsm_SHA224; + pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -4195,7 +4195,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA256_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA256; ++ pssParam.hashAlg = HashAlgo::shsm_SHA256; + pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -4213,7 +4213,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA384_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA384; ++ pssParam.hashAlg = HashAlgo::shsm_SHA384; + pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -4231,7 +4231,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA512_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA512; ++ pssParam.hashAlg = HashAlgo::shsm_SHA512; + pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -5086,27 +5086,27 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + unsigned long expectedMgf; + switch(CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) { + case CKM_SHA_1: +- pssParam.hashAlg = HashAlgo::SHA1; ++ pssParam.hashAlg = HashAlgo::shsm_SHA1; + pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + expectedMgf = CKG_MGF1_SHA1; + break; + case CKM_SHA224: +- pssParam.hashAlg = HashAlgo::SHA224; ++ pssParam.hashAlg = HashAlgo::shsm_SHA224; + pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + expectedMgf = CKG_MGF1_SHA224; + break; + case CKM_SHA256: +- pssParam.hashAlg = HashAlgo::SHA256; ++ pssParam.hashAlg = HashAlgo::shsm_SHA256; + pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + expectedMgf = CKG_MGF1_SHA256; + break; + case CKM_SHA384: +- pssParam.hashAlg = HashAlgo::SHA384; ++ pssParam.hashAlg = HashAlgo::shsm_SHA384; + pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + expectedMgf = CKG_MGF1_SHA384; + break; + case CKM_SHA512: +- pssParam.hashAlg = HashAlgo::SHA512; ++ pssParam.hashAlg = HashAlgo::shsm_SHA512; + pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + expectedMgf = CKG_MGF1_SHA512; + break; +@@ -5135,7 +5135,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA1_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA1; ++ pssParam.hashAlg = HashAlgo::shsm_SHA1; + pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -5153,7 +5153,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA224_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA224; ++ pssParam.hashAlg = HashAlgo::shsm_SHA224; + pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -5171,7 +5171,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA256_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA256; ++ pssParam.hashAlg = HashAlgo::shsm_SHA256; + pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -5189,7 +5189,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA384_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA384; ++ pssParam.hashAlg = HashAlgo::shsm_SHA384; + pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +@@ -5207,7 +5207,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA512_PKCS_PSS; +- pssParam.hashAlg = HashAlgo::SHA512; ++ pssParam.hashAlg = HashAlgo::shsm_SHA512; + pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; +diff --git a/src/lib/crypto/AsymmetricAlgorithm.h b/src/lib/crypto/AsymmetricAlgorithm.h +index b0f02fd..ddc5071 100644 +--- a/src/lib/crypto/AsymmetricAlgorithm.h ++++ b/src/lib/crypto/AsymmetricAlgorithm.h +@@ -106,7 +106,7 @@ struct AsymRSAMGF + + struct RSA_PKCS_PSS_PARAMS + { +- HashAlgo::Type hashAlg; ++ HashAlgo::shsm_Type hashAlg; + AsymRSAMGF::Type mgf; + size_t sLen; + }; +diff --git a/src/lib/crypto/BotanCryptoFactory.cpp b/src/lib/crypto/BotanCryptoFactory.cpp +index 4ad743d..e1a84e7 100644 +--- a/src/lib/crypto/BotanCryptoFactory.cpp ++++ b/src/lib/crypto/BotanCryptoFactory.cpp +@@ -161,24 +161,24 @@ AsymmetricAlgorithm* BotanCryptoFactory::getAsymmetricAlgorithm(AsymAlgo::Type a + } + + // Create a concrete instance of a hash algorithm +-HashAlgorithm* BotanCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) ++HashAlgorithm* BotanCryptoFactory::getHashAlgorithm(HashAlgo::shsm_Type algorithm) + { + switch (algorithm) + { +- case HashAlgo::MD5: ++ case HashAlgo::shsm_MD5: + return new BotanMD5(); +- case HashAlgo::SHA1: ++ case HashAlgo::shsm_SHA1: + return new BotanSHA1(); +- case HashAlgo::SHA224: ++ case HashAlgo::shsm_SHA224: + return new BotanSHA224(); +- case HashAlgo::SHA256: ++ case HashAlgo::shsm_SHA256: + return new BotanSHA256(); +- case HashAlgo::SHA384: ++ case HashAlgo::shsm_SHA384: + return new BotanSHA384(); +- case HashAlgo::SHA512: ++ case HashAlgo::shsm_SHA512: + return new BotanSHA512(); + #ifdef WITH_GOST +- case HashAlgo::GOST: ++ case HashAlgo::shsm_GOST: + return new BotanGOSTR3411(); + #endif + default: +diff --git a/src/lib/crypto/BotanCryptoFactory.h b/src/lib/crypto/BotanCryptoFactory.h +index 788ae37..87d2fb3 100644 +--- a/src/lib/crypto/BotanCryptoFactory.h ++++ b/src/lib/crypto/BotanCryptoFactory.h +@@ -66,7 +66,7 @@ public: + AsymmetricAlgorithm* getAsymmetricAlgorithm(AsymAlgo::Type algorithm); + + // Create a concrete instance of a hash algorithm +- HashAlgorithm* getHashAlgorithm(HashAlgo::Type algorithm); ++ HashAlgorithm* getHashAlgorithm(HashAlgo::shsm_Type algorithm); + + // Create a concrete instance of a MAC algorithm + MacAlgorithm* getMacAlgorithm(MacAlgo::Type algorithm); +diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp +index 3ed450e..75c8036 100644 +--- a/src/lib/crypto/BotanRSA.cpp ++++ b/src/lib/crypto/BotanRSA.cpp +@@ -188,7 +188,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA1 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); +@@ -210,7 +210,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA224 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); +@@ -232,7 +232,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA256 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); +@@ -254,7 +254,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA384 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); +@@ -276,7 +276,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA512 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); +@@ -532,7 +532,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA1 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); +@@ -554,7 +554,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA224 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); +@@ -576,7 +576,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA256 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); +@@ -598,7 +598,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA384 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); +@@ -620,7 +620,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA512 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); +@@ -1119,23 +1119,23 @@ std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const v + size_t allowedLen = 0; + switch (((RSA_PKCS_PSS_PARAMS*) param)->hashAlg) + { +- case HashAlgo::SHA1: ++ case HashAlgo::shsm_SHA1: + hashStr = "SHA-160"; + allowedLen = 20; + break; +- case HashAlgo::SHA224: ++ case HashAlgo::shsm_SHA224: + hashStr = "SHA-224"; + allowedLen = 28; + break; +- case HashAlgo::SHA256: ++ case HashAlgo::shsm_SHA256: + hashStr = "SHA-256"; + allowedLen = 32; + break; +- case HashAlgo::SHA384: ++ case HashAlgo::shsm_SHA384: + hashStr = "SHA-384"; + allowedLen = 48; + break; +- case HashAlgo::SHA512: ++ case HashAlgo::shsm_SHA512: + hashStr = "SHA-512"; + allowedLen = 64; + break; +diff --git a/src/lib/crypto/CryptoFactory.h b/src/lib/crypto/CryptoFactory.h +index 761e473..c49f4eb 100644 +--- a/src/lib/crypto/CryptoFactory.h ++++ b/src/lib/crypto/CryptoFactory.h +@@ -71,7 +71,7 @@ public: + virtual void recycleAsymmetricAlgorithm(AsymmetricAlgorithm* toRecycle); + + // Create a concrete instance of a hash algorithm +- virtual HashAlgorithm* getHashAlgorithm(HashAlgo::Type algorithm) = 0; ++ virtual HashAlgorithm* getHashAlgorithm(HashAlgo::shsm_Type algorithm) = 0; + + // Recycle a hash algorithm instance -- override this function in the derived + // class if you need to perform specific clean-up +diff --git a/src/lib/crypto/HashAlgorithm.h b/src/lib/crypto/HashAlgorithm.h +index ca2ae08..0e33174 100644 +--- a/src/lib/crypto/HashAlgorithm.h ++++ b/src/lib/crypto/HashAlgorithm.h +@@ -38,16 +38,16 @@ + + struct HashAlgo + { +- enum Type ++ enum shsm_Type + { +- Unknown, +- MD5, +- SHA1, +- SHA224, +- SHA256, +- SHA384, +- SHA512, +- GOST ++ shsm_Unknown, ++ shsm_MD5, ++ shsm_SHA1, ++ shsm_SHA224, ++ shsm_SHA256, ++ shsm_SHA384, ++ shsm_SHA512, ++ shsm_GOST + }; + }; + +diff --git a/src/lib/crypto/OSSLCMAC.cpp b/src/lib/crypto/OSSLCMAC.cpp +index 554c308..af47776 100644 +--- a/src/lib/crypto/OSSLCMAC.cpp ++++ b/src/lib/crypto/OSSLCMAC.cpp +@@ -40,8 +40,10 @@ const EVP_CIPHER* OSSLCMACDES::getEVPCipher() const + case 56: + ERROR_MSG("Only supporting 3DES"); + return NULL; ++#ifndef WITH_WOLFSSL + case 112: + return EVP_des_ede_cbc(); ++#endif + case 168: + return EVP_des_ede3_cbc(); + default: +diff --git a/src/lib/crypto/OSSLCryptoFactory.cpp b/src/lib/crypto/OSSLCryptoFactory.cpp +index 32daca2..1988889 100644 +--- a/src/lib/crypto/OSSLCryptoFactory.cpp ++++ b/src/lib/crypto/OSSLCryptoFactory.cpp +@@ -141,6 +141,7 @@ OSSLCryptoFactory::OSSLCryptoFactory() + // Initialise OpenSSL + OpenSSL_add_all_algorithms(); + ++#ifndef WITH_WOLFSSL + #if !( OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) ) + // Make sure RDRAND is loaded first + ENGINE_load_rdrand(); +@@ -161,6 +162,7 @@ OSSLCryptoFactory::OSSLCryptoFactory() + WARNING_MSG("ENGINE_set_default returned %lu\n", ERR_get_error()); + } + } ++#endif + + // Initialise the one-and-only RNG + rng = new OSSLRNG(); +@@ -236,10 +238,12 @@ OSSLCryptoFactory::~OSSLCryptoFactory() + } + #endif + ++#ifndef WITH_WOLFSSL + // Finish the rd_rand engine + ENGINE_finish(rdrand_engine); + ENGINE_free(rdrand_engine); + rdrand_engine = NULL; ++#endif + + // Destroy the one-and-only RNG + delete rng; +@@ -340,24 +344,24 @@ AsymmetricAlgorithm* OSSLCryptoFactory::getAsymmetricAlgorithm(AsymAlgo::Type al + } + + // Create a concrete instance of a hash algorithm +-HashAlgorithm* OSSLCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) ++HashAlgorithm* OSSLCryptoFactory::getHashAlgorithm(HashAlgo::shsm_Type algorithm) + { + switch (algorithm) + { +- case HashAlgo::MD5: ++ case HashAlgo::shsm_MD5: + return new OSSLMD5(); +- case HashAlgo::SHA1: ++ case HashAlgo::shsm_SHA1: + return new OSSLSHA1(); +- case HashAlgo::SHA224: ++ case HashAlgo::shsm_SHA224: + return new OSSLSHA224(); +- case HashAlgo::SHA256: ++ case HashAlgo::shsm_SHA256: + return new OSSLSHA256(); +- case HashAlgo::SHA384: ++ case HashAlgo::shsm_SHA384: + return new OSSLSHA384(); +- case HashAlgo::SHA512: ++ case HashAlgo::shsm_SHA512: + return new OSSLSHA512(); + #ifdef WITH_GOST +- case HashAlgo::GOST: ++ case HashAlgo::shsm_GOST: + return new OSSLGOSTR3411(); + #endif + default: +@@ -392,8 +396,10 @@ MacAlgorithm* OSSLCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) + case MacAlgo::HMAC_GOST: + return new OSSLHMACGOSTR3411(); + #endif ++#ifndef WITH_WOLFSSL /* wolfSSL only supports cmac with aes */ + case MacAlgo::CMAC_DES: + return new OSSLCMACDES(); ++#endif + case MacAlgo::CMAC_AES: + return new OSSLCMACAES(); + default: +diff --git a/src/lib/crypto/OSSLCryptoFactory.h b/src/lib/crypto/OSSLCryptoFactory.h +index d718b69..7cedd33 100644 +--- a/src/lib/crypto/OSSLCryptoFactory.h ++++ b/src/lib/crypto/OSSLCryptoFactory.h +@@ -65,7 +65,7 @@ public: + virtual AsymmetricAlgorithm* getAsymmetricAlgorithm(AsymAlgo::Type algorithm); + + // Create a concrete instance of a hash algorithm +- virtual HashAlgorithm* getHashAlgorithm(HashAlgo::Type algorithm); ++ virtual HashAlgorithm* getHashAlgorithm(HashAlgo::shsm_Type algorithm); + + // Create a concrete instance of a MAC algorithm + virtual MacAlgorithm* getMacAlgorithm(MacAlgo::Type algorithm); +@@ -103,8 +103,10 @@ private: + + // The one-and-only RNG instance + RNG* rng; ++#ifndef WITH_WOLFSSL + // And RDRAND engine to use with it + ENGINE *rdrand_engine; ++#endif + + #ifdef WITH_GOST + // The GOST engine +diff --git a/src/lib/crypto/OSSLDES.cpp b/src/lib/crypto/OSSLDES.cpp +index 4fb56b5..e7dd193 100644 +--- a/src/lib/crypto/OSSLDES.cpp ++++ b/src/lib/crypto/OSSLDES.cpp +@@ -79,8 +79,10 @@ const EVP_CIPHER* OSSLDES::getCipher() const + { + case 56: + return EVP_des_cbc(); ++#ifndef WITH_WOLFSSL + case 112: + return EVP_des_ede_cbc(); ++#endif + case 168: + return EVP_des_ede3_cbc(); + }; +@@ -91,12 +93,15 @@ const EVP_CIPHER* OSSLDES::getCipher() const + { + case 56: + return EVP_des_ecb(); ++#ifndef WITH_WOLFSSL + case 112: + return EVP_des_ede_ecb(); ++#endif + case 168: + return EVP_des_ede3_ecb(); + }; + } ++#ifndef WITH_WOLFSSL + else if (currentCipherMode == SymMode::OFB) + { + switch(currentKey->getBitLen()) +@@ -121,6 +126,7 @@ const EVP_CIPHER* OSSLDES::getCipher() const + return EVP_des_ede3_cfb(); + }; + } ++#endif + + ERROR_MSG("Invalid DES cipher mode %i", currentCipherMode); + +diff --git a/src/lib/crypto/OSSLDHPrivateKey.cpp b/src/lib/crypto/OSSLDHPrivateKey.cpp +index 5571a88..ce1256f 100644 +--- a/src/lib/crypto/OSSLDHPrivateKey.cpp ++++ b/src/lib/crypto/OSSLDHPrivateKey.cpp +@@ -209,6 +209,7 @@ void OSSLDHPrivateKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -223,6 +224,7 @@ void OSSLDHPrivateKey::createOSSLKey() + + #else + DH_set_method(dh, DH_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_p = OSSL::byteString2bn(p); +diff --git a/src/lib/crypto/OSSLDHPublicKey.cpp b/src/lib/crypto/OSSLDHPublicKey.cpp +index e261726..2241fed 100644 +--- a/src/lib/crypto/OSSLDHPublicKey.cpp ++++ b/src/lib/crypto/OSSLDHPublicKey.cpp +@@ -150,6 +150,7 @@ void OSSLDHPublicKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -164,6 +165,7 @@ void OSSLDHPublicKey::createOSSLKey() + + #else + DH_set_method(dh, DH_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_p = OSSL::byteString2bn(p); +diff --git a/src/lib/crypto/OSSLDSA.cpp b/src/lib/crypto/OSSLDSA.cpp +index 06b5d50..2f49415 100644 +--- a/src/lib/crypto/OSSLDSA.cpp ++++ b/src/lib/crypto/OSSLDSA.cpp +@@ -121,24 +121,24 @@ bool OSSLDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + return false; + } + +- HashAlgo::Type hash = HashAlgo::Unknown; ++ HashAlgo::shsm_Type hash = HashAlgo::shsm_Unknown; + + switch (mechanism) + { + case AsymMech::DSA_SHA1: +- hash = HashAlgo::SHA1; ++ hash = HashAlgo::shsm_SHA1; + break; + case AsymMech::DSA_SHA224: +- hash = HashAlgo::SHA224; ++ hash = HashAlgo::shsm_SHA224; + break; + case AsymMech::DSA_SHA256: +- hash = HashAlgo::SHA256; ++ hash = HashAlgo::shsm_SHA256; + break; + case AsymMech::DSA_SHA384: +- hash = HashAlgo::SHA384; ++ hash = HashAlgo::shsm_SHA384; + break; + case AsymMech::DSA_SHA512: +- hash = HashAlgo::SHA512; ++ hash = HashAlgo::shsm_SHA512; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); +@@ -309,24 +309,24 @@ bool OSSLDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + return false; + } + +- HashAlgo::Type hash = HashAlgo::Unknown; ++ HashAlgo::shsm_Type hash = HashAlgo::shsm_Unknown; + + switch (mechanism) + { + case AsymMech::DSA_SHA1: +- hash = HashAlgo::SHA1; ++ hash = HashAlgo::shsm_SHA1; + break; + case AsymMech::DSA_SHA224: +- hash = HashAlgo::SHA224; ++ hash = HashAlgo::shsm_SHA224; + break; + case AsymMech::DSA_SHA256: +- hash = HashAlgo::SHA256; ++ hash = HashAlgo::shsm_SHA256; + break; + case AsymMech::DSA_SHA384: +- hash = HashAlgo::SHA384; ++ hash = HashAlgo::shsm_SHA384; + break; + case AsymMech::DSA_SHA512: +- hash = HashAlgo::SHA512; ++ hash = HashAlgo::shsm_SHA512; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); +@@ -481,8 +481,10 @@ bool OSSLDSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter + return false; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + DSA_set_method(dsa, DSA_get_default_method()); ++#endif + + BIGNUM* bn_p = OSSL::byteString2bn(params->getP()); + BIGNUM* bn_q = OSSL::byteString2bn(params->getQ()); +diff --git a/src/lib/crypto/OSSLDSAPrivateKey.cpp b/src/lib/crypto/OSSLDSAPrivateKey.cpp +index 527e041..edc5228 100644 +--- a/src/lib/crypto/OSSLDSAPrivateKey.cpp ++++ b/src/lib/crypto/OSSLDSAPrivateKey.cpp +@@ -226,6 +226,7 @@ void OSSLDSAPrivateKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -240,6 +241,7 @@ void OSSLDSAPrivateKey::createOSSLKey() + + #else + DSA_set_method(dsa, DSA_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_p = OSSL::byteString2bn(p); +diff --git a/src/lib/crypto/OSSLDSAPublicKey.cpp b/src/lib/crypto/OSSLDSAPublicKey.cpp +index 38ecc79..5cf9b2d 100644 +--- a/src/lib/crypto/OSSLDSAPublicKey.cpp ++++ b/src/lib/crypto/OSSLDSAPublicKey.cpp +@@ -167,6 +167,7 @@ void OSSLDSAPublicKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -181,6 +182,7 @@ void OSSLDSAPublicKey::createOSSLKey() + + #else + DSA_set_method(dsa, DSA_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_p = OSSL::byteString2bn(p); +diff --git a/src/lib/crypto/OSSLECPrivateKey.cpp b/src/lib/crypto/OSSLECPrivateKey.cpp +index 4f6b055..3129f71 100644 +--- a/src/lib/crypto/OSSLECPrivateKey.cpp ++++ b/src/lib/crypto/OSSLECPrivateKey.cpp +@@ -43,16 +43,20 @@ OSSLECPrivateKey::OSSLECPrivateKey() + { + eckey = EC_KEY_new(); + ++#ifndef WITH_WOLFSSL + // For PKCS#8 encoding + EC_KEY_set_enc_flags(eckey, EC_PKEY_NO_PUBKEY); ++#endif + } + + OSSLECPrivateKey::OSSLECPrivateKey(const EC_KEY* inECKEY) + { + eckey = EC_KEY_new(); + ++#ifndef WITH_WOLFSSL + // For PKCS#8 encoding + EC_KEY_set_enc_flags(eckey, EC_PKEY_NO_PUBKEY); ++#endif + + setFromOSSL(inECKEY); + } +diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp +index 1e5638a..64b8fd2 100644 +--- a/src/lib/crypto/OSSLRSA.cpp ++++ b/src/lib/crypto/OSSLRSA.cpp +@@ -108,7 +108,9 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, + + int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_PKCS1_PADDING); + ++#ifndef WITH_WOLFSSL + RSA_blinding_off(rsa); ++#endif + + if (sigLen == -1) + { +@@ -147,23 +149,23 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, + + switch (pssParam->hashAlg) + { +- case HashAlgo::SHA1: ++ case HashAlgo::shsm_SHA1: + hash = EVP_sha1(); + allowedLen = 20; + break; +- case HashAlgo::SHA224: ++ case HashAlgo::shsm_SHA224: + hash = EVP_sha224(); + allowedLen = 28; + break; +- case HashAlgo::SHA256: ++ case HashAlgo::shsm_SHA256: + hash = EVP_sha256(); + allowedLen = 32; + break; +- case HashAlgo::SHA384: ++ case HashAlgo::shsm_SHA384: + hash = EVP_sha384(); + allowedLen = 48; + break; +- case HashAlgo::SHA512: ++ case HashAlgo::shsm_SHA512: + hash = EVP_sha512(); + allowedLen = 64; + break; +@@ -214,7 +216,9 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, + + int sigLen = RSA_private_encrypt(osslKey->getN().size(), &em[0], &signature[0], rsa, RSA_NO_PADDING); + ++#ifndef WITH_WOLFSSL + RSA_blinding_off(rsa); ++#endif + + if (sigLen == -1) + { +@@ -263,7 +267,9 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, + + int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_NO_PADDING); + ++#ifndef WITH_WOLFSSL + RSA_blinding_off(rsa); ++#endif + + if (sigLen == -1) + { +@@ -302,32 +308,32 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + return false; + } + +- HashAlgo::Type hash1 = HashAlgo::Unknown; +- HashAlgo::Type hash2 = HashAlgo::Unknown; ++ HashAlgo::shsm_Type hash1 = HashAlgo::shsm_Unknown; ++ HashAlgo::shsm_Type hash2 = HashAlgo::shsm_Unknown; + + switch (mechanism) + { + case AsymMech::RSA_MD5_PKCS: +- hash1 = HashAlgo::MD5; ++ hash1 = HashAlgo::shsm_MD5; + break; + case AsymMech::RSA_SHA1_PKCS: +- hash1 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_SHA1; + break; + case AsymMech::RSA_SHA224_PKCS: +- hash1 = HashAlgo::SHA224; ++ hash1 = HashAlgo::shsm_SHA224; + break; + case AsymMech::RSA_SHA256_PKCS: +- hash1 = HashAlgo::SHA256; ++ hash1 = HashAlgo::shsm_SHA256; + break; + case AsymMech::RSA_SHA384_PKCS: +- hash1 = HashAlgo::SHA384; ++ hash1 = HashAlgo::shsm_SHA384; + break; + case AsymMech::RSA_SHA512_PKCS: +- hash1 = HashAlgo::SHA512; ++ hash1 = HashAlgo::shsm_SHA512; + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA1 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); +@@ -344,11 +350,11 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::signFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_SHA1; + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA224 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); +@@ -365,11 +371,11 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::signFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA224; ++ hash1 = HashAlgo::shsm_SHA224; + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA256 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); +@@ -386,11 +392,11 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::signFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA256; ++ hash1 = HashAlgo::shsm_SHA256; + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA384 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); +@@ -407,11 +413,11 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::signFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA384; ++ hash1 = HashAlgo::shsm_SHA384; + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA512 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); +@@ -428,11 +434,11 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::signFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA512; ++ hash1 = HashAlgo::shsm_SHA512; + break; + case AsymMech::RSA_SSL: +- hash1 = HashAlgo::MD5; +- hash2 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_MD5; ++ hash2 = HashAlgo::shsm_SHA1; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); +@@ -459,7 +465,7 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, + return false; + } + +- if (hash2 != HashAlgo::Unknown) ++ if (hash2 != HashAlgo::shsm_Unknown) + { + pSecondHash = CryptoFactory::i()->getHashAlgorithm(hash2); + +@@ -600,9 +606,11 @@ bool OSSLRSA::signFinal(ByteString& signature) + isPSS = true; + hash = EVP_sha512(); + break; ++#ifndef WITH_WOLFSSL + case AsymMech::RSA_SSL: + type = NID_md5_sha1; + break; ++#endif + default: + break; + } +@@ -665,7 +673,9 @@ bool OSSLRSA::signFinal(ByteString& signature) + } + } + ++#ifndef WITH_WOLFSSL + RSA_blinding_off(rsa); ++#endif + + signature.resize(sigLen); + +@@ -757,23 +767,23 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, + + switch (pssParam->hashAlg) + { +- case HashAlgo::SHA1: ++ case HashAlgo::shsm_SHA1: + hash = EVP_sha1(); + allowedLen = 20; + break; +- case HashAlgo::SHA224: ++ case HashAlgo::shsm_SHA224: + hash = EVP_sha224(); + allowedLen = 28; + break; +- case HashAlgo::SHA256: ++ case HashAlgo::shsm_SHA256: + hash = EVP_sha256(); + allowedLen = 32; + break; +- case HashAlgo::SHA384: ++ case HashAlgo::shsm_SHA384: + hash = EVP_sha384(); + allowedLen = 48; + break; +- case HashAlgo::SHA512: ++ case HashAlgo::shsm_SHA512: + hash = EVP_sha512(); + allowedLen = 64; + break; +@@ -859,32 +869,32 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + return false; + } + +- HashAlgo::Type hash1 = HashAlgo::Unknown; +- HashAlgo::Type hash2 = HashAlgo::Unknown; ++ HashAlgo::shsm_Type hash1 = HashAlgo::shsm_Unknown; ++ HashAlgo::shsm_Type hash2 = HashAlgo::shsm_Unknown; + + switch (mechanism) + { + case AsymMech::RSA_MD5_PKCS: +- hash1 = HashAlgo::MD5; ++ hash1 = HashAlgo::shsm_MD5; + break; + case AsymMech::RSA_SHA1_PKCS: +- hash1 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_SHA1; + break; + case AsymMech::RSA_SHA224_PKCS: +- hash1 = HashAlgo::SHA224; ++ hash1 = HashAlgo::shsm_SHA224; + break; + case AsymMech::RSA_SHA256_PKCS: +- hash1 = HashAlgo::SHA256; ++ hash1 = HashAlgo::shsm_SHA256; + break; + case AsymMech::RSA_SHA384_PKCS: +- hash1 = HashAlgo::SHA384; ++ hash1 = HashAlgo::shsm_SHA384; + break; + case AsymMech::RSA_SHA512_PKCS: +- hash1 = HashAlgo::SHA512; ++ hash1 = HashAlgo::shsm_SHA512; + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA1 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); +@@ -901,11 +911,11 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_SHA1; + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA224 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); +@@ -922,11 +932,11 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA224; ++ hash1 = HashAlgo::shsm_SHA224; + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA256 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); +@@ -943,11 +953,11 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA256; ++ hash1 = HashAlgo::shsm_SHA256; + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA384 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); +@@ -964,11 +974,11 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA384; ++ hash1 = HashAlgo::shsm_SHA384; + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || +- ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || ++ ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::shsm_SHA512 || + ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); +@@ -985,11 +995,11 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } +- hash1 = HashAlgo::SHA512; ++ hash1 = HashAlgo::shsm_SHA512; + break; + case AsymMech::RSA_SSL: +- hash1 = HashAlgo::MD5; +- hash2 = HashAlgo::SHA1; ++ hash1 = HashAlgo::shsm_MD5; ++ hash2 = HashAlgo::shsm_SHA1; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); +@@ -1016,7 +1026,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, + return false; + } + +- if (hash2 != HashAlgo::Unknown) ++ if (hash2 != HashAlgo::shsm_Unknown) + { + pSecondHash = CryptoFactory::i()->getHashAlgorithm(hash2); + +@@ -1154,9 +1164,11 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) + isPSS = true; + hash = EVP_sha512(); + break; ++#ifndef WITH_WOLFSSL + case AsymMech::RSA_SSL: + type = NID_md5_sha1; + break; ++#endif + default: + break; + } +diff --git a/src/lib/crypto/OSSLRSAPrivateKey.cpp b/src/lib/crypto/OSSLRSAPrivateKey.cpp +index 26065cf..ee62a07 100644 +--- a/src/lib/crypto/OSSLRSAPrivateKey.cpp ++++ b/src/lib/crypto/OSSLRSAPrivateKey.cpp +@@ -288,6 +288,7 @@ void OSSLRSAPrivateKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -302,6 +303,7 @@ void OSSLRSAPrivateKey::createOSSLKey() + + #else + RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_p = OSSL::byteString2bn(p); +diff --git a/src/lib/crypto/OSSLRSAPublicKey.cpp b/src/lib/crypto/OSSLRSAPublicKey.cpp +index 2a6893b..8145079 100644 +--- a/src/lib/crypto/OSSLRSAPublicKey.cpp ++++ b/src/lib/crypto/OSSLRSAPublicKey.cpp +@@ -132,6 +132,7 @@ void OSSLRSAPublicKey::createOSSLKey() + return; + } + ++#ifndef WITH_WOLFSSL + // Use the OpenSSL implementation and not any engine + #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + +@@ -146,6 +147,7 @@ void OSSLRSAPublicKey::createOSSLKey() + + #else + RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); ++#endif + #endif + + BIGNUM* bn_n = OSSL::byteString2bn(n); +diff --git a/src/lib/crypto/SymmetricKey.cpp b/src/lib/crypto/SymmetricKey.cpp +index 182ce70..6e4f007 100644 +--- a/src/lib/crypto/SymmetricKey.cpp ++++ b/src/lib/crypto/SymmetricKey.cpp +@@ -66,7 +66,7 @@ ByteString SymmetricKey::getKeyCheckValue() const + { + ByteString digest; + +- HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA1); ++ HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA1); + if (hash == NULL) return digest; + + if (!hash->hashInit() || +diff --git a/src/lib/crypto/test/AESTests.cpp b/src/lib/crypto/test/AESTests.cpp +index 58d58af..41f29b5 100644 +--- a/src/lib/crypto/test/AESTests.cpp ++++ b/src/lib/crypto/test/AESTests.cpp +@@ -815,6 +815,7 @@ void AESTests::testGCM() + "10", + "61353B4C2806934A777FF51FA22A4755699B2A714FCDC6F83766E5F97B6C742373806900E49F24B22B097544D4896B424989B5E1EBAC0F07C23F45983612D2E79E3B0785561BE14AACA2FCCB" + }, ++#ifndef WITH_WOLFSSL /* wolfSSL doesn't support IV longer than block size */ + { + "FEFFE9928665731C6D6A8F9467308308", + "9313225DF88406E555909C5AFF5269AA6A7A9538534F7DA1E4C303D2A318A728C3C0C95156809539FCF0E2429A6B525416AEDBF5A0DE6A57A637B39B", +@@ -823,6 +824,7 @@ void AESTests::testGCM() + "10", + "8CE24998625615B603A033ACA13FB894BE9112A5C3A211A8BA262A3CCA7E2CA701E4A9A4FBA43C90CCDCB281D48C7C6FD62875D2ACA417034C34AEE5619CC5AEFFFE0BFA462AF43C1699D050" + }, ++#endif + { + "FEFFE9928665731C6D6A8F9467308308", + "CAFEBABEFACEDBAD", +@@ -831,6 +833,7 @@ void AESTests::testGCM() + "C", + "61353B4C2806934A777FF51FA22A4755699B2A714FCDC6F83766E5F97B6C742373806900E49F24B22B097544D4896B424989B5E1EBAC0F07C23F45983612D2E79E3B0785561BE14A" + }, ++#ifndef WITH_WOLFSSL /* wolfSSL doesn't support IV longer than block size */ + { + "FEFFE9928665731C6D6A8F9467308308", + "9313225DF88406E555909C5AFF5269AA6A7A9538534F7DA1E4C303D2A318A728C3C0C95156809539FCF0E2429A6B525416AEDBF5A0DE6A57A637B39B", +@@ -839,6 +842,7 @@ void AESTests::testGCM() + "C", + "8CE24998625615B603A033ACA13FB894BE9112A5C3A211A8BA262A3CCA7E2CA701E4A9A4FBA43C90CCDCB281D48C7C6FD62875D2ACA417034C34AEE5619CC5AEFFFE0BFA462AF43C" + } ++#endif + }; + + char test192[8][6][256] = +@@ -883,6 +887,7 @@ void AESTests::testGCM() + "10", + "0f10f599ae14a154ed24b36e25324db8c566632ef2bbb34f8347280fc4507057fddc29df9a471f75c66541d4d4dad1c9e93a19a58e8b473fa0f062f765dcc57fcf623a24094fcca40d3533f8" + }, ++#ifndef WITH_WOLFSSL /* wolfSSL doesn't support IV longer than block size */ + { + "feffe9928665731c6d6a8f9467308308feffe9928665731c", + "9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b525416aedbf5a0de6a57a637b39b", +@@ -891,6 +896,7 @@ void AESTests::testGCM() + "10", + "d27e88681ce3243c4830165a8fdcf9ff1de9a1d8e6b447ef6ef7b79828666e4581e79012af34ddd9e2f037589b292db3e67c036745fa22e7e9b7373bdcf566ff291c25bbb8568fc3d376a6d9" + }, ++#endif + { + "feffe9928665731c6d6a8f9467308308feffe9928665731c", + "cafebabefacedbaddecaf888", +@@ -951,6 +957,7 @@ void AESTests::testGCM() + "10", + "c3762df1ca787d32ae47c13bf19844cbaf1ae14d0b976afac52ff7d79bba9de0feb582d33934a4f0954cc2363bc73f7862ac430e64abe499f47c9b1f3a337dbf46a792c45e454913fe2ea8f2", + }, ++#ifndef WITH_WOLFSSL /* wolfSSL doesn't support IV longer than block size */ + { + "feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308", + "9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b525416aedbf5a0de6a57a637b39b", +@@ -959,6 +966,7 @@ void AESTests::testGCM() + "10", + "5a8def2f0c9e53f1f75d7853659e2a20eeb2b22aafde6419a058ab4f6f746bf40fc0c3b780f244452da3ebf1c5d82cdea2418997200ef82e44ae7e3fa44a8266ee1c8eb0c8b5d4cf5ae9f19a" + }, ++#endif + { + "feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308", + "cafebabefacedbaddecaf888", +@@ -977,7 +985,11 @@ void AESTests::testGCM() + } + }; + ++#ifndef WITH_WOLFSSL /* wolfSSL doesn't support IV longer than block size */ + for (int i = 0; i < 8; i++) ++#else ++ for (int i = 0; i < 6; i++) ++#endif + { + ByteString keyData128(test128[i][0]); + ByteString keyData192(test192[i][0]); +diff --git a/src/lib/crypto/test/DESTests.cpp b/src/lib/crypto/test/DESTests.cpp +index bcb1c6b..70aa6c7 100644 +--- a/src/lib/crypto/test/DESTests.cpp ++++ b/src/lib/crypto/test/DESTests.cpp +@@ -76,6 +76,7 @@ void DESTests::testCBC() + "0940278947239572" + }; + ++#ifndef WITH_WOLFSSL + char testKeys112[][33] = + { + "00000000000000000000000000000000", +@@ -84,6 +85,7 @@ void DESTests::testCBC() + "64398647034486943598534703463870", + "87406984068406984607412103517413" + }; ++#endif + #endif + + char testKeys168[][49] = +@@ -230,8 +232,10 @@ void DESTests::testCBC() + #ifndef WITH_FIPS + ByteString keyData56(testKeys56[i]); + CPPUNIT_ASSERT(keyData56.size() == 8); ++#ifndef WITH_WOLFSSL + ByteString keyData112(testKeys112[i]); + CPPUNIT_ASSERT(keyData112.size() == 16); ++#endif + #endif + ByteString keyData168(testKeys168[i]); + CPPUNIT_ASSERT(keyData168.size() == 24); +@@ -239,8 +243,10 @@ void DESTests::testCBC() + #ifndef WITH_FIPS + DESKey desKey56(56); + CPPUNIT_ASSERT(desKey56.setKeyBits(keyData56)); ++#ifndef WITH_WOLFSSL + DESKey desKey112(112); + CPPUNIT_ASSERT(desKey112.setKeyBits(keyData112)); ++#endif + #endif + DESKey desKey168(168); + CPPUNIT_ASSERT(desKey168.setKeyBits(keyData168)); +@@ -281,6 +287,7 @@ void DESTests::testCBC() + + CPPUNIT_ASSERT(shsmPlainText == plainText); + ++#ifndef WITH_WOLFSSL + // Test 112-bit key + cipherText = ByteString(testResult[i][j][1]); + +@@ -307,6 +314,7 @@ void DESTests::testCBC() + shsmPlainText += OB; + + CPPUNIT_ASSERT(shsmPlainText == plainText); ++#endif + #endif + + // Test 168-bit key +@@ -351,6 +359,7 @@ void DESTests::testECB() + "0940278947239572" + }; + ++#ifndef WITH_WOLFSSL + char testKeys112[][33] = + { + "00000000000000000000000000000000", +@@ -359,6 +368,7 @@ void DESTests::testECB() + "64398647034486943598534703463870", + "87406984068406984607412103517413" + }; ++#endif + #endif + + char testKeys168[][49] = +@@ -505,8 +515,10 @@ void DESTests::testECB() + #ifndef WITH_FIPS + ByteString keyData56(testKeys56[i]); + CPPUNIT_ASSERT(keyData56.size() == 8); ++#ifndef WITH_WOLFSSL + ByteString keyData112(testKeys112[i]); + CPPUNIT_ASSERT(keyData112.size() == 16); ++#endif + #endif + ByteString keyData168(testKeys168[i]); + CPPUNIT_ASSERT(keyData168.size() == 24); +@@ -514,8 +526,10 @@ void DESTests::testECB() + #ifndef WITH_FIPS + DESKey desKey56(56); + CPPUNIT_ASSERT(desKey56.setKeyBits(keyData56)); ++#ifndef WITH_WOLFSSL + DESKey desKey112(112); + CPPUNIT_ASSERT(desKey112.setKeyBits(keyData112)); ++#endif + #endif + DESKey desKey168(168); + CPPUNIT_ASSERT(desKey168.setKeyBits(keyData168)); +@@ -556,6 +570,7 @@ void DESTests::testECB() + + CPPUNIT_ASSERT(shsmPlainText == plainText); + ++#ifndef WITH_WOLFSSL + // Test 112-bit key + cipherText = ByteString(testResult[i][j][1]); + +@@ -582,6 +597,7 @@ void DESTests::testECB() + shsmPlainText += OB; + + CPPUNIT_ASSERT(shsmPlainText == plainText); ++#endif + #endif + + // Test 168-bit key +@@ -614,6 +630,7 @@ void DESTests::testECB() + } + } + ++#ifndef WITH_WOLFSSL + void DESTests::testOFB() + { + #ifndef WITH_FIPS +@@ -626,6 +643,7 @@ void DESTests::testOFB() + "0940278947239572" + }; + ++#ifndef WITH_WOLFSSL + char testKeys112[][33] = + { + "00000000000000000000000000000000", +@@ -634,6 +652,7 @@ void DESTests::testOFB() + "64398647034486943598534703463870", + "87406984068406984607412103517413" + }; ++#endif + #endif + + char testKeys168[][49] = +@@ -780,8 +799,10 @@ void DESTests::testOFB() + #ifndef WITH_FIPS + ByteString keyData56(testKeys56[i]); + CPPUNIT_ASSERT(keyData56.size() == 8); ++#ifndef WITH_WOLFSSL + ByteString keyData112(testKeys112[i]); + CPPUNIT_ASSERT(keyData112.size() == 16); ++#endif + #endif + ByteString keyData168(testKeys168[i]); + CPPUNIT_ASSERT(keyData168.size() == 24); +@@ -789,8 +810,10 @@ void DESTests::testOFB() + #ifndef WITH_FIPS + DESKey desKey56(56); + CPPUNIT_ASSERT(desKey56.setKeyBits(keyData56)); ++#ifndef WITH_WOLFSSL + DESKey desKey112(112); + CPPUNIT_ASSERT(desKey112.setKeyBits(keyData112)); ++#endif + #endif + DESKey desKey168(168); + CPPUNIT_ASSERT(desKey168.setKeyBits(keyData168)); +@@ -831,6 +854,7 @@ void DESTests::testOFB() + + CPPUNIT_ASSERT(shsmPlainText == plainText); + ++#ifndef WITH_WOLFSSL + // Test 112-bit key + cipherText = ByteString(testResult[i][j][1]); + +@@ -857,6 +881,7 @@ void DESTests::testOFB() + shsmPlainText += OB; + + CPPUNIT_ASSERT(shsmPlainText == plainText); ++#endif + #endif + + // Test 168-bit key +@@ -901,6 +926,7 @@ void DESTests::testCFB() + "0940278947239572" + }; + ++#ifndef WITH_WOLFSSL + char testKeys112[][33] = + { + "00000000000000000000000000000000", +@@ -909,6 +935,7 @@ void DESTests::testCFB() + "64398647034486943598534703463870", + "87406984068406984607412103517413" + }; ++#endif + #endif + + char testKeys168[][49] = +@@ -1054,8 +1081,10 @@ void DESTests::testCFB() + #ifndef WITH_FIPS + ByteString keyData56(testKeys56[i]); + CPPUNIT_ASSERT(keyData56.size() == 8); ++#ifndef WITH_WOLFSSL + ByteString keyData112(testKeys112[i]); + CPPUNIT_ASSERT(keyData112.size() == 16); ++#endif + #endif + ByteString keyData168(testKeys168[i]); + CPPUNIT_ASSERT(keyData168.size() == 24); +@@ -1063,8 +1092,10 @@ void DESTests::testCFB() + #ifndef WITH_FIPS + DESKey desKey56(56); + CPPUNIT_ASSERT(desKey56.setKeyBits(keyData56)); ++#ifndef WITH_WOLFSSL + DESKey desKey112(112); + CPPUNIT_ASSERT(desKey112.setKeyBits(keyData112)); ++#endif + #endif + DESKey desKey168(168); + CPPUNIT_ASSERT(desKey168.setKeyBits(keyData168)); +@@ -1105,6 +1136,7 @@ void DESTests::testCFB() + + CPPUNIT_ASSERT(shsmPlainText == plainText); + ++#ifndef WITH_WOLFSSL + // Test 112-bit key + cipherText = ByteString(testResult[i][j][1]); + +@@ -1131,6 +1163,7 @@ void DESTests::testCFB() + shsmPlainText += OB; + + CPPUNIT_ASSERT(shsmPlainText == plainText); ++#endif + #endif + + // Test 168-bit key +@@ -1162,3 +1195,4 @@ void DESTests::testCFB() + } + } + } ++#endif +diff --git a/src/lib/crypto/test/DESTests.h b/src/lib/crypto/test/DESTests.h +index 0834462..fc119fa 100644 +--- a/src/lib/crypto/test/DESTests.h ++++ b/src/lib/crypto/test/DESTests.h +@@ -42,8 +42,10 @@ class DESTests : public CppUnit::TestFixture + CPPUNIT_TEST(testBlockSize); + CPPUNIT_TEST(testCBC); + CPPUNIT_TEST(testECB); ++#ifndef WITH_WOLFSSL + CPPUNIT_TEST(testOFB); + CPPUNIT_TEST(testCFB); ++#endif + CPPUNIT_TEST_SUITE_END(); + + public: +diff --git a/src/lib/crypto/test/DHTests.cpp b/src/lib/crypto/test/DHTests.cpp +index 354cdac..a9ba2ac 100644 +--- a/src/lib/crypto/test/DHTests.cpp ++++ b/src/lib/crypto/test/DHTests.cpp +@@ -97,7 +97,12 @@ void DHTests::testKeyGeneration() + + priv = (DHPrivateKey*) kp->getPrivateKey(); + ++#ifndef WITH_WOLFSSL + CPPUNIT_ASSERT(priv->getX().bits() == 128); ++#else ++ /* wolfSSL rounds up the desired length */ ++ CPPUNIT_ASSERT(priv->getX().bits() > 160 && priv->getX().bits() < 170); ++#endif + + dh->recycleParameters(p); + dh->recycleKeyPair(kp); +diff --git a/src/lib/crypto/test/DSATests.cpp b/src/lib/crypto/test/DSATests.cpp +index 80f2514..342e13b 100644 +--- a/src/lib/crypto/test/DSATests.cpp ++++ b/src/lib/crypto/test/DSATests.cpp +@@ -72,7 +72,9 @@ void DSATests::testKeyGeneration() + std::vector keySizes; + #ifndef WITH_FIPS + keySizes.push_back(1024); ++#ifndef WITH_WOLFSSL + keySizes.push_back(1536); ++#endif + #else + keySizes.push_back(1024); + #endif +@@ -205,7 +207,9 @@ void DSATests::testSigningVerifying() + std::vector keySizes; + #ifndef WITH_FIPS + keySizes.push_back(1024); ++#ifndef WITH_WOLFSSL + keySizes.push_back(1536); ++#endif + #else + keySizes.push_back(1024); + #endif +diff --git a/src/lib/crypto/test/ECDSATests.cpp b/src/lib/crypto/test/ECDSATests.cpp +index 3c29d06..74990d4 100644 +--- a/src/lib/crypto/test/ECDSATests.cpp ++++ b/src/lib/crypto/test/ECDSATests.cpp +@@ -189,15 +189,15 @@ void ECDSATests::testSigningVerifying() + ECParameters *p; + + // Curves/Hashes to test +- std::vector > totest; ++ std::vector > totest; + // Add X9.62 prime256v1 +- totest.push_back(std::make_pair(ByteString("06082a8648ce3d030107"), HashAlgo::SHA256)); ++ totest.push_back(std::make_pair(ByteString("06082a8648ce3d030107"), HashAlgo::shsm_SHA256)); + // Add secp384r1 +- totest.push_back(std::make_pair(ByteString("06052b81040022"), HashAlgo::SHA384)); ++ totest.push_back(std::make_pair(ByteString("06052b81040022"), HashAlgo::shsm_SHA384)); + // Add secp521r1 +- totest.push_back(std::make_pair(ByteString("06052b81040023"), HashAlgo::SHA384)); ++ totest.push_back(std::make_pair(ByteString("06052b81040023"), HashAlgo::shsm_SHA384)); + +- for (std::vector >::iterator k = totest.begin(); k != totest.end(); k++) ++ for (std::vector >::iterator k = totest.begin(); k != totest.end(); k++) + { + // Get parameters + p = new ECParameters; +@@ -241,8 +241,8 @@ void ECDSATests::testSignVerifyKnownVector() + ECPublicKey* pubKey2 = (ECPublicKey*) ecdsa->newPublicKey(); + ECPrivateKey* privKey1 = (ECPrivateKey*) ecdsa->newPrivateKey(); + ECPrivateKey* privKey2 = (ECPrivateKey*) ecdsa->newPrivateKey(); +- HashAlgorithm* hash1 = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA256); +- HashAlgorithm* hash2 = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA384); ++ HashAlgorithm* hash1 = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA256); ++ HashAlgorithm* hash2 = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA384); + + // Reconstruct public and private key #1 + ByteString ec1 = "06082a8648ce3d030107"; // X9.62 prime256v1 +diff --git a/src/lib/crypto/test/GOSTTests.cpp b/src/lib/crypto/test/GOSTTests.cpp +index 50d42e0..2c3bb5f 100644 +--- a/src/lib/crypto/test/GOSTTests.cpp ++++ b/src/lib/crypto/test/GOSTTests.cpp +@@ -86,7 +86,7 @@ void GOSTTests::testHash() + char testResult[512] = "3EC65819A084AD30712C4B3EB69CE130A8C7221EA3D8A9996D4BA6F298BC39F9"; + + // Get a GOST R 34.11-94 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::GOST)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_GOST)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), gostHash; +@@ -175,7 +175,7 @@ void GOSTTests::testHmac() + + void GOSTTests::testHashKnownVector() + { +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::GOST)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_GOST)) != NULL); + + // Message to hash for test #1 + ByteString msg = "6d65737361676520646967657374"; // "message digest" +diff --git a/src/lib/crypto/test/HashTests.cpp b/src/lib/crypto/test/HashTests.cpp +index f02adbc..17a0837 100644 +--- a/src/lib/crypto/test/HashTests.cpp ++++ b/src/lib/crypto/test/HashTests.cpp +@@ -63,7 +63,7 @@ void HashTests::testMD5() + char testResult[512] = "7299FE513582D71A3B9EA1E9F45F95FD"; + + // Get a MD5 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::MD5)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_MD5)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +@@ -99,7 +99,7 @@ void HashTests::testSHA1() + char testResult[512] = "9A5BD96DC0CD3B0089FBB6BE7D56BEE638431F5A"; + + // Get a SHA1 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA1)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA1)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +@@ -134,7 +134,7 @@ void HashTests::testSHA224() + char testResult[512] = "A4E71A239CED53E936011DF80B516A07DFF13BB5B05BE43C46C05CCD"; + + // Get a SHA224 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA224)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA224)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +@@ -169,7 +169,7 @@ void HashTests::testSHA256() + char testResult[512] = "3902802C215A5271439FE3E81AC7F21DA55545F71193A8DA8BEB0EAC8046A43B"; + + // Get a SHA256 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA256)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA256)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +@@ -204,7 +204,7 @@ void HashTests::testSHA384() + char testResult[512] = "753659D55E4198325A3FED0A35761EC45038E8963B7525BF00D5A6A5D904DD9FA3FC80AB020185E08B14992ECC36A744"; + + // Get a SHA384 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA384)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA384)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +@@ -239,7 +239,7 @@ void HashTests::testSHA512() + char testResult[512] = "E1483A8525CE39705D14D60D8B19BD89087AED5FE6D8913AF8FC3F6F4EA2C1BB5957E205294B1EFAF20AE5EE39A9522F38B4514C3C15ED70BCBBD5821E385F95"; + + // Get a SHA512 hash instance +- CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA512)) != NULL); ++ CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA512)) != NULL); + + ByteString b(testData); + ByteString osslHash(testResult), shsmHash; +diff --git a/src/lib/crypto/test/MacTests.cpp b/src/lib/crypto/test/MacTests.cpp +index 8a3db1e..5e3cefc 100644 +--- a/src/lib/crypto/test/MacTests.cpp ++++ b/src/lib/crypto/test/MacTests.cpp +@@ -316,6 +316,7 @@ void MacTests::testHMACSHA512() + rng = NULL; + } + ++#ifndef WITH_WOLFSSL + void MacTests::testCMACDES2() + { + // Test vectors from NIST SP 800-38B +@@ -463,6 +464,7 @@ void MacTests::testCMACDES3() + mac = NULL; + rng = NULL; + } ++#endif + + void MacTests::testCMACAES128() + { +diff --git a/src/lib/crypto/test/MacTests.h b/src/lib/crypto/test/MacTests.h +index 9e6fa99..54be803 100644 +--- a/src/lib/crypto/test/MacTests.h ++++ b/src/lib/crypto/test/MacTests.h +@@ -48,8 +48,10 @@ class MacTests : public CppUnit::TestFixture + CPPUNIT_TEST(testHMACSHA256); + CPPUNIT_TEST(testHMACSHA384); + CPPUNIT_TEST(testHMACSHA512); ++#ifndef WITH_WOLFSSL + CPPUNIT_TEST(testCMACDES2); + CPPUNIT_TEST(testCMACDES3); ++#endif + CPPUNIT_TEST(testCMACAES128); + CPPUNIT_TEST(testCMACAES192); + CPPUNIT_TEST(testCMACAES256); +@@ -64,8 +66,10 @@ public: + void testHMACSHA256(); + void testHMACSHA384(); + void testHMACSHA512(); ++#ifndef WITH_WOLFSSL + void testCMACDES2(); + void testCMACDES3(); ++#endif + void testCMACAES128(); + void testCMACAES192(); + void testCMACAES256(); +diff --git a/src/lib/crypto/test/RSATests.cpp b/src/lib/crypto/test/RSATests.cpp +index 6af1e19..a6ea4a4 100644 +--- a/src/lib/crypto/test/RSATests.cpp ++++ b/src/lib/crypto/test/RSATests.cpp +@@ -79,10 +79,12 @@ void RSATests::testKeyGeneration() + // Key sizes to test + std::vector keySizes; + keySizes.push_back(1024); ++#ifndef WITH_WOLFSSL + #ifndef WITH_FIPS + keySizes.push_back(1025); + #endif + keySizes.push_back(1280); ++#endif + keySizes.push_back(2048); + //keySizes.push_back(4096); + +@@ -279,11 +281,11 @@ void RSATests::testSigningVerifying() + + /* Max salt length for SHA512 and 1024-bit RSA is 62 bytes */ + RSA_PKCS_PSS_PARAMS pssParams[] = { +- { HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20 }, +- { HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 0 }, +- { HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 0 }, +- { HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48 }, +- { HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 62 } ++ { HashAlgo::shsm_SHA1, AsymRSAMGF::MGF1_SHA1, 20 }, ++ { HashAlgo::shsm_SHA224, AsymRSAMGF::MGF1_SHA224, 0 }, ++ { HashAlgo::shsm_SHA256, AsymRSAMGF::MGF1_SHA256, 0 }, ++ { HashAlgo::shsm_SHA384, AsymRSAMGF::MGF1_SHA384, 48 }, ++ { HashAlgo::shsm_SHA512, AsymRSAMGF::MGF1_SHA512, 62 } + }; + + for (std::vector::iterator e = exponents.begin(); e != exponents.end(); e++) +@@ -581,7 +583,7 @@ void RSATests::testSignVerifyKnownVector() + + CPPUNIT_ASSERT(rsa->verifyInit(pubKey3, AsymMech::RSA_SHA1_PKCS)); + CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign3)); +- CPPUNIT_ASSERT(rsa->verifyFinal(expectedSignature3)); ++ CPPUNIT_ASSERT(rsa->verifyFinal(signature3)); + + #ifndef WITH_FIPS + rsa->recyclePublicKey(pubKey1); +diff --git a/src/lib/data_mgr/RFC4880.cpp b/src/lib/data_mgr/RFC4880.cpp +index 9ea23bd..880da86 100644 +--- a/src/lib/data_mgr/RFC4880.cpp ++++ b/src/lib/data_mgr/RFC4880.cpp +@@ -58,7 +58,7 @@ bool RFC4880::PBEDeriveKey(const ByteString& password, ByteString& salt, AESKey* + unsigned int iter = PBE_ITERATION_BASE_COUNT + salt[salt.size() - 1]; + + // Get a hash instance +- HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA256); ++ HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::shsm_SHA256); + + if (hash == NULL) + { +diff --git a/src/lib/session_mgr/Session.cpp b/src/lib/session_mgr/Session.cpp +index 5db36fd..4569964 100644 +--- a/src/lib/session_mgr/Session.cpp ++++ b/src/lib/session_mgr/Session.cpp +@@ -45,7 +45,7 @@ Session::Session(Slot* inSlot, bool inIsReadWrite, CK_VOID_PTR inPApplication, C + operation = SESSION_OP_NONE; + findOp = NULL; + digestOp = NULL; +- hashAlgo = HashAlgo::Unknown; ++ hashAlgo = HashAlgo::shsm_Unknown; + macOp = NULL; + asymmetricCryptoOp = NULL; + symmetricCryptoOp = NULL; +@@ -72,7 +72,7 @@ Session::Session() + operation = SESSION_OP_NONE; + findOp = NULL; + digestOp = NULL; +- hashAlgo = HashAlgo::Unknown; ++ hashAlgo = HashAlgo::shsm_Unknown; + macOp = NULL; + asymmetricCryptoOp = NULL; + symmetricCryptoOp = NULL; +@@ -271,12 +271,12 @@ HashAlgorithm* Session::getDigestOp() + return digestOp; + } + +-void Session::setHashAlgo(HashAlgo::Type inHashAlgo) ++void Session::setHashAlgo(HashAlgo::shsm_Type inHashAlgo) + { + hashAlgo = inHashAlgo; + } + +-HashAlgo::Type Session::getHashAlgo() ++HashAlgo::shsm_Type Session::getHashAlgo() + { + return hashAlgo; + } +diff --git a/src/lib/session_mgr/Session.h b/src/lib/session_mgr/Session.h +index 142aaa5..8cce237 100644 +--- a/src/lib/session_mgr/Session.h ++++ b/src/lib/session_mgr/Session.h +@@ -85,8 +85,8 @@ public: + // Digest + void setDigestOp(HashAlgorithm* inDigestOp); + HashAlgorithm* getDigestOp(); +- void setHashAlgo(HashAlgo::Type inHashAlgo); +- HashAlgo::Type getHashAlgo(); ++ void setHashAlgo(HashAlgo::shsm_Type inHashAlgo); ++ HashAlgo::shsm_Type getHashAlgo(); + + // Mac + void setMacOp(MacAlgorithm* inMacOp); +@@ -148,7 +148,7 @@ private: + + // Digest + HashAlgorithm* digestOp; +- HashAlgo::Type hashAlgo; ++ HashAlgo::shsm_Type hashAlgo; + + // Mac + MacAlgorithm* macOp; +-- +2.34.1 + diff --git a/softhsm/README b/softhsm/README new file mode 100644 index 00000000..7d0301a2 --- /dev/null +++ b/softhsm/README @@ -0,0 +1,6 @@ +This folder contains patches for SoftHSMv2 to work with wolfSSL. Patches make it +easier to add support for newer versions of a target library. The format of +the patch names is: + .patch +Instructions for applying each patch are included in the patch commit +message.